@symbiote-native/sensors 0.2.1 → 0.4.0

package/README.md

@@ -3,8 +3,8 @@
 A wrapper package for [SymbioteNative](../../README.md) that makes
 [`expo-sensors`](https://github.com/expo/expo/tree/main/packages/expo-sensors) — Accelerometer,
 Barometer, DeviceMotion, Gyroscope, LightSensor, Magnetometer, MagnetometerUncalibrated, and
-Pedometer — usable from **every** adapter, React, Vue, and Angular. Unlike this repo's other
-wrappers ([`@symbiote-native/slider`](../slider), [`@symbiote-native/navigation`](../navigation),
+Pedometer — usable from **every** adapter, React, Vue, Svelte, Solid, and Angular. Unlike this
+repo's other wrappers ([`@symbiote-native/slider`](../slider), [`@symbiote-native/navigation`](../navigation),
 [`@symbiote-native/splash-screen`](../splash-screen)), `expo-sensors` isn't a plain RN native
 module or view — it's built on `expo-modules-core`, so its native code autolinks straight out of
 `node_modules` via `expo-modules-autolinking`, no proxy `react-native.config.cjs`/podspec to ship.
@@ -29,12 +29,12 @@ Unlike a plain RN native module, `expo-sensors`' native code is discovered by
 into the native host app **once**, covering this package and every future `expo-modules-core`
 package with zero further changes:
 
-| Platform | Touches |
-|---|---|
-| iOS | `ios/Podfile` — add `use_expo_modules!` |
-| iOS | `AppDelegate.swift` — Expo's runtime-bootstrap hook |
-| Android | `settings.gradle` / `app/build.gradle` — resolve and include the Expo Gradle projects |
-| Android | `MainApplication.kt` — Expo's bootstrap hook, plus a hand-written native-module name map (there's no `expo` meta-package here to auto-generate one) |
+| Platform | Touches                                                                                                                                             |
+| -------- | --------------------------------------------------------------------------------------------------------------------------------------------------- |
+| iOS      | `ios/Podfile` — add `use_expo_modules!`                                                                                                             |
+| iOS      | `AppDelegate.swift` — Expo's runtime-bootstrap hook                                                                                                 |
+| Android  | `settings.gradle` / `app/build.gradle` — resolve and include the Expo Gradle projects                                                               |
+| Android  | `MainApplication.kt` — Expo's bootstrap hook, plus a hand-written native-module name map (there's no `expo` meta-package here to auto-generate one) |
 
 Full mechanics — the Podfile pieces that normally ship inside the `expo` package, the `expo`
 peer-dependency exclusion list, per-sensor permission strings — live in the
@@ -55,12 +55,16 @@ src/core/             DeviceSensor base class + one class per sensor (Accelerome
                        module by name through expo-modules-core's requireNativeModule.
 src/react/hooks/       @symbiote-native/sensors/react   — useAccelerometer, useBarometer, ...
 src/vue/composables/   @symbiote-native/sensors/vue     — useAccelerometer, useBarometer, ... (same names)
+src/svelte/runes/      @symbiote-native/sensors/svelte  — useAccelerometer, useBarometer, ... (same names)
+src/solid/primitives/  @symbiote-native/sensors/solid   — createAccelerometer, createBarometer, ...
 src/angular/services/  @symbiote-native/sensors/angular — AccelerometerService, BarometerService, ...
 ```
 
-Each adapter's hook/composable/service is a thin lifecycle wrapper (subscribe on mount, unsubscribe
-on unmount) over the same `core` singleton — the subscription, permission, and update-interval
-logic is written once and shared by all three.
+Each adapter's hook/composable/rune/primitive/service is a thin lifecycle wrapper (subscribe on
+mount, unsubscribe on unmount) over the same `core` singleton — the subscription, permission, and
+update-interval logic is written once and shared by all of them. Solid is the one adapter that
+renames: its ecosystem calls a composable reactive function a **primitive** and reserves `use*` for
+consuming something that already exists, so `useAccelerometer` is `createAccelerometer` there.
 
 ## Use it
 
@@ -72,7 +76,12 @@ import { useAccelerometer } from '@symbiote-native/sensors/react';
 
 function SensorsScreen() {
   const accelerometer = useAccelerometer();
-  return <Text>{accelerometer && `x ${accelerometer.x} · y ${accelerometer.y} · z ${accelerometer.z}`}</Text>;
+  return (
+    <Text>
+      {accelerometer &&
+        `x ${accelerometer.x} · y ${accelerometer.y} · z ${accelerometer.z}`}
+    </Text>
+  );
 }
 ```
 
@@ -84,34 +93,65 @@ import { useAccelerometer } from '@symbiote-native/sensors/vue';
 const accelerometer = useAccelerometer();
 </script>
 <template>
-  <Text>{{ accelerometer && `x ${accelerometer.x} · y ${accelerometer.y} · z ${accelerometer.z}` }}</Text>
+  <Text>{{
+    accelerometer &&
+    `x ${accelerometer.x} · y ${accelerometer.y} · z ${accelerometer.z}`
+  }}</Text>
 </template>
 ```
 
+```tsx
+// Solid — a primitive returning an Accessor, read as `accelerometer()`. `Show` must be imported
+// explicitly (see .claude/rules/solid-descriptor-bridge.md), and hands its child an accessor.
+import { Show } from 'solid-js';
+import { createAccelerometer } from '@symbiote-native/sensors/solid';
+
+function SensorsScreen() {
+  const accelerometer = createAccelerometer();
+  return (
+    <Text>
+      <Show when={accelerometer()}>
+        {reading => `x ${reading().x} · y ${reading().y} · z ${reading().z}`}
+      </Show>
+    </Text>
+  );
+}
+```
+
 ```ts
 // Angular
 import { Component, inject } from '@angular/core';
 import { AccelerometerService } from '@symbiote-native/sensors/angular';
 
-@Component({ /* ... */ })
+@Component({/* ... */})
 export class SensorsScreen {
   readonly accelerometer = inject(AccelerometerService).connect();
 }
 ```
 
-All three examples above mirror the real canary demo screens —
+The examples above mirror the real canary demo screens —
 `examples/expo-react/screens/SensorsScreen.tsx`, `examples/expo-vue-sfc/screens/SensorsScreen.vue`,
 `examples/expo-vue-tsx/screens/SensorsScreen.tsx`, `examples/expo-angular/src/screens/SensorsScreen.ts`.
 
-Every hook/composable/`connect()` takes an optional `updateIntervalMs` and returns `null` until the
-first native reading arrives — check `isAvailableAsync()` separately if you need to distinguish
-"not available on this device" from "no reading yet" (see [Notes](#notes) below).
+Every hook/composable/rune/primitive/`connect()` takes an optional `updateIntervalMs` and returns
+`null` until the first native reading arrives — check `isAvailableAsync()` separately if you need
+to distinguish "not available on this device" from "no reading yet" (see [Notes](#notes) below).
+
+On Solid `updateIntervalMs` accepts an **accessor** as well as a number
+(`createAccelerometer(() => intervalMs())`). A Solid component body runs once, so a plain number is
+read once and pins the sample rate for the primitive's whole life; pass the accessor whenever the
+rate is derived from state and it re-applies on every change — without re-subscribing, since the
+native listener is per-sensor and unaffected by the rate.
 
 ### Pedometer — free functions, no shared instance
 
 ```ts
-import { watchStepCount, getStepCountAsync, isAvailableAsync } from '@symbiote-native/sensors';
-import { usePedometer } from '@symbiote-native/sensors/react'; // or /vue, /angular's PedometerService
+import {
+  watchStepCount,
+  getStepCountAsync,
+  isAvailableAsync,
+} from '@symbiote-native/sensors';
+import { usePedometer } from '@symbiote-native/sensors/react'; // or /vue, /svelte, /solid's createPedometer, /angular's PedometerService
 
 const pedometer = usePedometer(); // { steps: number } | null, live-subscribed
 const { steps } = await getStepCountAsync(startDate, endDate); // one-shot, iOS only in practice
@@ -134,5 +174,5 @@ const { steps } = await getStepCountAsync(startDate, endDate); // one-shot, iOS
 
 No Fabric/Descriptor angle at all — a sensor is a pure `EventEmitter` + async-function surface,
 never a view. Tests inject a fake native-module object in place of the real
-`requireNativeModule` resolution (`src/core/**/*.test.ts`, `src/{react,vue,angular}/**/*.test.{ts,tsx}`),
+`requireNativeModule` resolution (`src/core/**/*.test.ts`, `src/{react,vue,svelte,solid,angular}/**/*.test.{ts,tsx}`),
 the same pattern `expo-sensors` itself uses upstream — no `installFabric()`, no ViewConfig.

package/build/angular/index.d.ts

@@ -3,7 +3,7 @@ export type { IAccelerometerMeasurement } from '../core';
 export { BarometerService } from './services/barometer.service';
 export type { IBarometerMeasurement } from '../core';
 export { DeviceMotionService } from './services/device-motion.service';
-export { DeviceMotionOrientation, gravity, type IDeviceMotionMeasurement } from '../core';
+export { DeviceMotionOrientation, gravity, type IDeviceMotionMeasurement, } from '../core';
 export { GyroscopeService } from './services/gyroscope.service';
 export type { IGyroscopeMeasurement } from '../core';
 export { LightSensorService } from './services/light-sensor.service';

package/build/angular/index.js

@@ -3,7 +3,7 @@
 export { AccelerometerService } from './services/accelerometer.service/index.js';
 export { BarometerService } from './services/barometer.service/index.js';
 export { DeviceMotionService } from './services/device-motion.service/index.js';
-export { DeviceMotionOrientation, gravity } from '../core/index.js';
+export { DeviceMotionOrientation, gravity, } from '../core/index.js';
 export { GyroscopeService } from './services/gyroscope.service/index.js';
 export { LightSensorService } from './services/light-sensor.service/index.js';
 export { MagnetometerService } from './services/magnetometer.service/index.js';

package/build/angular/services/accelerometer.service/index.js

@@ -32,20 +32,14 @@ var __runInitializers = (this && this.__runInitializers) || function (thisArg, i
     }
     return useValue ? value : void 0;
 };
-import { effect, inject, Injectable, Injector, signal } from '@angular/core';
+import { effect, inject, Injectable, Injector, signal, } from '@angular/core';
 import { Accelerometer } from '../../../core/index.js';
-// Angular twin of React's `useAccelerometer` hook and Vue's `useAccelerometer` composable.
-// Angular has no per-instance hook — state and lifecycle live in DI instead, so `connect()`
-// stands in for the hook's role: call it ONCE (typically from a component's field initializer,
-// inside an injection context).
+// Angular twin of React's `useAccelerometer` hook / Vue's `useAccelerometer` composable.
+// Angular has no per-instance hook, so `connect()` stands in: call it ONCE, inside an injection
+// context (typically a component's field initializer).
 //
 //   readonly measurement = inject(AccelerometerService).connect();
 //   // template: {{ measurement()?.x }}
-//
-// Unlike HideAnimationService.connect(), there is no per-render config to re-sync — the
-// subscription doesn't depend on anything the caller's own signals could change between
-// renders — so a single effect() that subscribes once and cleans up once is enough; no
-// `updateConfig`-style effect that re-runs on every read is needed here.
 let AccelerometerService = (() => {
     let _classDecorators = [Injectable({ providedIn: 'root' })];
     let _classDescriptor;
@@ -60,13 +54,14 @@ let AccelerometerService = (() => {
             if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
             __runInitializers(_classThis, _classExtraInitializers);
         }
-        // Captured in the constructor (itself always run inside an injection context by Angular's
-        // own DI) so `connect()` can create an `effect()` even when called from plain field-initializer
-        // code that is not, on its own, an active injection context — mirrors HideAnimationService.
+        // Captured in the constructor (always an injection context) so `connect()` can build an
+        // `effect()` even when called from a field initializer that isn't one on its own.
         injector = inject(Injector);
         connect(updateIntervalMs) {
             const measurement = signal(null);
             effect(onCleanup => {
+                // updateIntervalMs applies once, at connect time — the effect has no reactive read to
+                // re-run on, so a later change is not picked up.
                 if (updateIntervalMs !== undefined) {
                     Accelerometer.setUpdateInterval(updateIntervalMs);
                 }

package/build/angular/services/barometer.service/index.js

@@ -32,20 +32,14 @@ var __runInitializers = (this && this.__runInitializers) || function (thisArg, i
     }
     return useValue ? value : void 0;
 };
-import { effect, inject, Injectable, Injector, signal } from '@angular/core';
+import { effect, inject, Injectable, Injector, signal, } from '@angular/core';
 import { Barometer } from '../../../core/index.js';
-// Angular twin of React's `useBarometer` hook and Vue's `useBarometer` composable.
-// Angular has no per-instance hook — state and lifecycle live in DI instead, so `connect()`
-// stands in for the hook's role: call it ONCE (typically from a component's field initializer,
-// inside an injection context).
+// Angular twin of React's `useBarometer` hook / Vue's `useBarometer` composable. Angular has no
+// per-instance hook, so `connect()` stands in: call it ONCE, inside an injection context
+// (typically a component's field initializer).
 //
 //   readonly measurement = inject(BarometerService).connect();
 //   // template: {{ measurement()?.pressure }}
-//
-// Unlike HideAnimationService.connect(), there is no per-render config to re-sync — the
-// subscription doesn't depend on anything the caller's own signals could change between
-// renders — so a single effect() that subscribes once and cleans up once is enough; no
-// `updateConfig`-style effect that re-runs on every read is needed here.
 let BarometerService = (() => {
     let _classDecorators = [Injectable({ providedIn: 'root' })];
     let _classDescriptor;
@@ -60,13 +54,14 @@ let BarometerService = (() => {
             if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
             __runInitializers(_classThis, _classExtraInitializers);
         }
-        // Captured in the constructor (itself always run inside an injection context by Angular's
-        // own DI) so `connect()` can create an `effect()` even when called from plain field-initializer
-        // code that is not, on its own, an active injection context — mirrors HideAnimationService.
+        // Captured in the constructor (always an injection context) so `connect()` can build an
+        // `effect()` even when called from a field initializer that isn't one on its own.
         injector = inject(Injector);
         connect(updateIntervalMs) {
             const measurement = signal(null);
             effect(onCleanup => {
+                // updateIntervalMs applies once, at connect time — the effect has no reactive read to
+                // re-run on, so a later change is not picked up.
                 if (updateIntervalMs !== undefined) {
                     Barometer.setUpdateInterval(updateIntervalMs);
                 }

package/build/angular/services/device-motion.service/index.js

@@ -32,20 +32,14 @@ var __runInitializers = (this && this.__runInitializers) || function (thisArg, i
     }
     return useValue ? value : void 0;
 };
-import { effect, inject, Injectable, Injector, signal } from '@angular/core';
+import { effect, inject, Injectable, Injector, signal, } from '@angular/core';
 import { DeviceMotion } from '../../../core/index.js';
-// Angular twin of React's `useDeviceMotion` hook and Vue's `useDeviceMotion` composable.
-// Angular has no per-instance hook — state and lifecycle live in DI instead, so `connect()`
-// stands in for the hook's role: call it ONCE (typically from a component's field initializer,
-// inside an injection context).
+// Angular twin of React's `useDeviceMotion` hook / Vue's `useDeviceMotion` composable. Angular
+// has no per-instance hook, so `connect()` stands in: call it ONCE, inside an injection context
+// (typically a component's field initializer).
 //
 //   readonly measurement = inject(DeviceMotionService).connect();
 //   // template: {{ measurement()?.rotation?.alpha }}
-//
-// Unlike HideAnimationService.connect(), there is no per-render config to re-sync — the
-// subscription doesn't depend on anything the caller's own signals could change between
-// renders — so a single effect() that subscribes once and cleans up once is enough; no
-// `updateConfig`-style effect that re-runs on every read is needed here.
 let DeviceMotionService = (() => {
     let _classDecorators = [Injectable({ providedIn: 'root' })];
     let _classDescriptor;
@@ -60,13 +54,14 @@ let DeviceMotionService = (() => {
             if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
             __runInitializers(_classThis, _classExtraInitializers);
         }
-        // Captured in the constructor (itself always run inside an injection context by Angular's
-        // own DI) so `connect()` can create an `effect()` even when called from plain field-initializer
-        // code that is not, on its own, an active injection context — mirrors HideAnimationService.
+        // Captured in the constructor (always an injection context) so `connect()` can build an
+        // `effect()` even when called from a field initializer that isn't one on its own.
         injector = inject(Injector);
         connect(updateIntervalMs) {
             const measurement = signal(null);
             effect(onCleanup => {
+                // updateIntervalMs applies once, at connect time — the effect has no reactive read to
+                // re-run on, so a later change is not picked up.
                 if (updateIntervalMs !== undefined) {
                     DeviceMotion.setUpdateInterval(updateIntervalMs);
                 }

package/build/angular/services/gyroscope.service/index.js

@@ -32,20 +32,14 @@ var __runInitializers = (this && this.__runInitializers) || function (thisArg, i
     }
     return useValue ? value : void 0;
 };
-import { effect, inject, Injectable, Injector, signal } from '@angular/core';
+import { effect, inject, Injectable, Injector, signal, } from '@angular/core';
 import { Gyroscope } from '../../../core/index.js';
-// Angular twin of React's `useGyroscope` hook and Vue's `useGyroscope` composable.
-// Angular has no per-instance hook — state and lifecycle live in DI instead, so `connect()`
-// stands in for the hook's role: call it ONCE (typically from a component's field initializer,
-// inside an injection context).
+// Angular twin of React's `useGyroscope` hook / Vue's `useGyroscope` composable. Angular has no
+// per-instance hook, so `connect()` stands in: call it ONCE, inside an injection context
+// (typically a component's field initializer).
 //
 //   readonly measurement = inject(GyroscopeService).connect();
 //   // template: {{ measurement()?.x }}
-//
-// Unlike HideAnimationService.connect(), there is no per-render config to re-sync — the
-// subscription doesn't depend on anything the caller's own signals could change between
-// renders — so a single effect() that subscribes once and cleans up once is enough; no
-// `updateConfig`-style effect that re-runs on every read is needed here.
 let GyroscopeService = (() => {
     let _classDecorators = [Injectable({ providedIn: 'root' })];
     let _classDescriptor;
@@ -60,13 +54,14 @@ let GyroscopeService = (() => {
             if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
             __runInitializers(_classThis, _classExtraInitializers);
         }
-        // Captured in the constructor (itself always run inside an injection context by Angular's
-        // own DI) so `connect()` can create an `effect()` even when called from plain field-initializer
-        // code that is not, on its own, an active injection context — mirrors HideAnimationService.
+        // Captured in the constructor (always an injection context) so `connect()` can build an
+        // `effect()` even when called from a field initializer that isn't one on its own.
         injector = inject(Injector);
         connect(updateIntervalMs) {
             const measurement = signal(null);
             effect(onCleanup => {
+                // updateIntervalMs applies once, at connect time — the effect has no reactive read to
+                // re-run on, so a later change is not picked up.
                 if (updateIntervalMs !== undefined) {
                     Gyroscope.setUpdateInterval(updateIntervalMs);
                 }

package/build/angular/services/light-sensor.service/index.js

@@ -32,20 +32,14 @@ var __runInitializers = (this && this.__runInitializers) || function (thisArg, i
     }
     return useValue ? value : void 0;
 };
-import { effect, inject, Injectable, Injector, signal } from '@angular/core';
+import { effect, inject, Injectable, Injector, signal, } from '@angular/core';
 import { LightSensor } from '../../../core/index.js';
-// Angular twin of React's `useLightSensor` hook and Vue's `useLightSensor` composable.
-// Angular has no per-instance hook — state and lifecycle live in DI instead, so `connect()`
-// stands in for the hook's role: call it ONCE (typically from a component's field initializer,
-// inside an injection context).
+// Angular twin of React's `useLightSensor` hook / Vue's `useLightSensor` composable. Angular
+// has no per-instance hook, so `connect()` stands in: call it ONCE, inside an injection context
+// (typically a component's field initializer).
 //
 //   readonly measurement = inject(LightSensorService).connect();
 //   // template: {{ measurement()?.illuminance }}
-//
-// Unlike HideAnimationService.connect(), there is no per-render config to re-sync — the
-// subscription doesn't depend on anything the caller's own signals could change between
-// renders — so a single effect() that subscribes once and cleans up once is enough; no
-// `updateConfig`-style effect that re-runs on every read is needed here.
 let LightSensorService = (() => {
     let _classDecorators = [Injectable({ providedIn: 'root' })];
     let _classDescriptor;
@@ -60,13 +54,14 @@ let LightSensorService = (() => {
             if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
             __runInitializers(_classThis, _classExtraInitializers);
         }
-        // Captured in the constructor (itself always run inside an injection context by Angular's
-        // own DI) so `connect()` can create an `effect()` even when called from plain field-initializer
-        // code that is not, on its own, an active injection context — mirrors HideAnimationService.
+        // Captured in the constructor (always an injection context) so `connect()` can build an
+        // `effect()` even when called from a field initializer that isn't one on its own.
         injector = inject(Injector);
         connect(updateIntervalMs) {
             const measurement = signal(null);
             effect(onCleanup => {
+                // updateIntervalMs applies once, at connect time — the effect has no reactive read to
+                // re-run on, so a later change is not picked up.
                 if (updateIntervalMs !== undefined) {
                     LightSensor.setUpdateInterval(updateIntervalMs);
                 }

package/build/angular/services/magnetometer-uncalibrated.service/index.js

@@ -32,20 +32,15 @@ var __runInitializers = (this && this.__runInitializers) || function (thisArg, i
     }
     return useValue ? value : void 0;
 };
-import { effect, inject, Injectable, Injector, signal } from '@angular/core';
-import { MagnetometerUncalibrated } from '../../../core/index.js';
-// Angular twin of React's `useMagnetometerUncalibrated` hook and Vue's
-// `useMagnetometerUncalibrated` composable. Angular has no per-instance hook — state and
-// lifecycle live in DI instead, so `connect()` stands in for the hook's role: call it ONCE
-// (typically from a component's field initializer, inside an injection context).
+import { effect, inject, Injectable, Injector, signal, } from '@angular/core';
+import { MagnetometerUncalibrated, } from '../../../core/index.js';
+// Angular twin of React's `useMagnetometerUncalibrated` hook / Vue's
+// `useMagnetometerUncalibrated` composable. Angular has no per-instance hook, so `connect()`
+// stands in: call it ONCE, inside an injection context (typically a component's field
+// initializer).
 //
 //   readonly measurement = inject(MagnetometerUncalibratedService).connect();
 //   // template: {{ measurement()?.x }}
-//
-// Unlike HideAnimationService.connect(), there is no per-render config to re-sync — the
-// subscription doesn't depend on anything the caller's own signals could change between
-// renders — so a single effect() that subscribes once and cleans up once is enough; no
-// `updateConfig`-style effect that re-runs on every read is needed here.
 let MagnetometerUncalibratedService = (() => {
     let _classDecorators = [Injectable({ providedIn: 'root' })];
     let _classDescriptor;
@@ -60,13 +55,14 @@ let MagnetometerUncalibratedService = (() => {
             if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
             __runInitializers(_classThis, _classExtraInitializers);
         }
-        // Captured in the constructor (itself always run inside an injection context by Angular's
-        // own DI) so `connect()` can create an `effect()` even when called from plain field-initializer
-        // code that is not, on its own, an active injection context — mirrors HideAnimationService.
+        // Captured in the constructor (always an injection context) so `connect()` can build an
+        // `effect()` even when called from a field initializer that isn't one on its own.
         injector = inject(Injector);
         connect(updateIntervalMs) {
             const measurement = signal(null);
             effect(onCleanup => {
+                // updateIntervalMs applies once, at connect time — the effect has no reactive read to
+                // re-run on, so a later change is not picked up.
                 if (updateIntervalMs !== undefined) {
                     MagnetometerUncalibrated.setUpdateInterval(updateIntervalMs);
                 }

package/build/angular/services/magnetometer.service/index.js

@@ -32,20 +32,14 @@ var __runInitializers = (this && this.__runInitializers) || function (thisArg, i
     }
     return useValue ? value : void 0;
 };
-import { effect, inject, Injectable, Injector, signal } from '@angular/core';
+import { effect, inject, Injectable, Injector, signal, } from '@angular/core';
 import { Magnetometer } from '../../../core/index.js';
-// Angular twin of React's `useMagnetometer` hook and Vue's `useMagnetometer` composable.
-// Angular has no per-instance hook — state and lifecycle live in DI instead, so `connect()`
-// stands in for the hook's role: call it ONCE (typically from a component's field initializer,
-// inside an injection context).
+// Angular twin of React's `useMagnetometer` hook / Vue's `useMagnetometer` composable. Angular
+// has no per-instance hook, so `connect()` stands in: call it ONCE, inside an injection context
+// (typically a component's field initializer).
 //
 //   readonly measurement = inject(MagnetometerService).connect();
 //   // template: {{ measurement()?.x }}
-//
-// Unlike HideAnimationService.connect(), there is no per-render config to re-sync — the
-// subscription doesn't depend on anything the caller's own signals could change between
-// renders — so a single effect() that subscribes once and cleans up once is enough; no
-// `updateConfig`-style effect that re-runs on every read is needed here.
 let MagnetometerService = (() => {
     let _classDecorators = [Injectable({ providedIn: 'root' })];
     let _classDescriptor;
@@ -60,13 +54,14 @@ let MagnetometerService = (() => {
             if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
             __runInitializers(_classThis, _classExtraInitializers);
         }
-        // Captured in the constructor (itself always run inside an injection context by Angular's
-        // own DI) so `connect()` can create an `effect()` even when called from plain field-initializer
-        // code that is not, on its own, an active injection context — mirrors HideAnimationService.
+        // Captured in the constructor (always an injection context) so `connect()` can build an
+        // `effect()` even when called from a field initializer that isn't one on its own.
         injector = inject(Injector);
         connect(updateIntervalMs) {
             const measurement = signal(null);
             effect(onCleanup => {
+                // updateIntervalMs applies once, at connect time — the effect has no reactive read to
+                // re-run on, so a later change is not picked up.
                 if (updateIntervalMs !== undefined) {
                     Magnetometer.setUpdateInterval(updateIntervalMs);
                 }

package/build/angular/services/pedometer.service/index.js

@@ -32,18 +32,15 @@ var __runInitializers = (this && this.__runInitializers) || function (thisArg, i
     }
     return useValue ? value : void 0;
 };
-import { effect, inject, Injectable, Injector, signal } from '@angular/core';
+import { effect, inject, Injectable, Injector, signal, } from '@angular/core';
 import { watchStepCount } from '../../../core/index.js';
-// Angular twin of React's `usePedometer` hook and Vue's `usePedometer` composable. Angular has
-// no per-instance hook — state and lifecycle live in DI instead, so `connect()` stands in for
-// the hook's role: call it ONCE (typically from a component's field initializer, inside an
-// injection context).
+// Angular twin of React's `usePedometer` hook / Vue's `usePedometer` composable. Angular has no
+// per-instance hook, so `connect()` stands in: call it ONCE, inside an injection context
+// (typically a component's field initializer). Pedometer has no setUpdateInterval, unlike the
+// other sensor services, so there is no interval param here.
 //
 //   readonly result = inject(PedometerService).connect();
 //   // template: {{ result()?.steps }}
-//
-// Unlike AccelerometerService.connect(), there is no updateIntervalMs to apply — Pedometer has
-// no setUpdateInterval — so a single effect() that subscribes once and cleans up once is enough.
 let PedometerService = (() => {
     let _classDecorators = [Injectable({ providedIn: 'root' })];
     let _classDescriptor;
@@ -58,9 +55,8 @@ let PedometerService = (() => {
             if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
             __runInitializers(_classThis, _classExtraInitializers);
         }
-        // Captured in the constructor (itself always run inside an injection context by Angular's own
-        // DI) so `connect()` can create an `effect()` even when called from plain field-initializer
-        // code that is not, on its own, an active injection context — mirrors AccelerometerService.
+        // Captured in the constructor (always an injection context) so `connect()` can build an
+        // `effect()` even when called from a field initializer that isn't one on its own.
         injector = inject(Injector);
         connect() {
             const result = signal(null);

package/build/core/device-motion.js

@@ -10,12 +10,11 @@ export var DeviceMotionOrientation;
 })(DeviceMotionOrientation || (DeviceMotionOrientation = {}));
 export class DeviceMotionSensor extends DeviceSensor {
     // 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.
+    // than hardcoded — mirrors upstream's dual exposure as an instance property and this
+    // standalone export.
     gravity = 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.
+// Same value as `DeviceMotion.gravity`, for callers that only need the constant.
 export const gravity = exponentDeviceMotion.Gravity;

package/build/core/index.d.ts

@@ -1,11 +1,11 @@
 export { Accelerometer, AccelerometerSensor, type IAccelerometerMeasurement, } from './accelerometer';
-export { Barometer, BarometerSensor, type IBarometerMeasurement } from './barometer';
+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 { 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 { DeviceSensor, type IListener, type INativeSensorModule, } from './device-sensor';
 export type { EventSubscription, PermissionExpiration, PermissionResponse, } from 'expo-modules-core';
 export { PermissionStatus } from 'expo-modules-core';

package/build/core/index.js

@@ -1,10 +1,10 @@
 export { Accelerometer, AccelerometerSensor, } from './accelerometer.js';
-export { Barometer, BarometerSensor } from './barometer.js';
+export { Barometer, BarometerSensor, } from './barometer.js';
 export { DeviceMotion, DeviceMotionSensor, DeviceMotionOrientation, gravity, } from './device-motion.js';
-export { Gyroscope, GyroscopeSensor } from './gyroscope.js';
-export { LightSensor, LightSensorSensor } from './light-sensor.js';
-export { Magnetometer, MagnetometerSensor } from './magnetometer.js';
+export { Gyroscope, GyroscopeSensor, } from './gyroscope.js';
+export { LightSensor, LightSensorSensor, } from './light-sensor.js';
+export { Magnetometer, MagnetometerSensor, } from './magnetometer.js';
 export { MagnetometerUncalibrated, MagnetometerUncalibratedSensor, } from './magnetometer-uncalibrated.js';
 export { watchStepCount, getStepCountAsync, isAvailableAsync, getPermissionsAsync, requestPermissionsAsync, } from './pedometer.js';
-export { DeviceSensor } from './device-sensor.js';
+export { DeviceSensor, } from './device-sensor.js';
 export { PermissionStatus } from 'expo-modules-core';

package/build/react/hooks/use-magnetometer-uncalibrated/index.js

@@ -1,7 +1,7 @@
 // React lifecycle wiring over the framework-agnostic MagnetometerUncalibrated singleton
 // (core/) — mirrors the lifecycle-bucket naming convention of adapters/react/src/hooks.
 import { useEffect, useState } from 'react';
-import { MagnetometerUncalibrated } from '../../../core/index.js';
+import { MagnetometerUncalibrated, } from '../../../core/index.js';
 export function useMagnetometerUncalibrated(updateIntervalMs) {
     const [measurement, setMeasurement] = useState(null);
     useEffect(() => {

package/build/react/index.d.ts

@@ -3,7 +3,7 @@ export type { IAccelerometerMeasurement } from '../core';
 export { useBarometer } from './hooks/use-barometer';
 export type { IBarometerMeasurement } from '../core';
 export { useDeviceMotion } from './hooks/use-device-motion';
-export { DeviceMotionOrientation, gravity, type IDeviceMotionMeasurement } from '../core';
+export { DeviceMotionOrientation, gravity, type IDeviceMotionMeasurement, } from '../core';
 export { useGyroscope } from './hooks/use-gyroscope';
 export type { IGyroscopeMeasurement } from '../core';
 export { useLightSensor } from './hooks/use-light-sensor';

package/build/react/index.js

@@ -5,7 +5,7 @@
 export { useAccelerometer } from './hooks/use-accelerometer/index.js';
 export { useBarometer } from './hooks/use-barometer/index.js';
 export { useDeviceMotion } from './hooks/use-device-motion/index.js';
-export { DeviceMotionOrientation, gravity } from '../core/index.js';
+export { DeviceMotionOrientation, gravity, } from '../core/index.js';
 export { useGyroscope } from './hooks/use-gyroscope/index.js';
 export { useLightSensor } from './hooks/use-light-sensor/index.js';
 export { useMagnetometer } from './hooks/use-magnetometer/index.js';

package/build/solid/index.d.ts

@@ -0,0 +1,10 @@
+export { createAccelerometer } from './primitives/create-accelerometer';
+export { createBarometer } from './primitives/create-barometer';
+export { createDeviceMotion } from './primitives/create-device-motion';
+export { createGyroscope } from './primitives/create-gyroscope';
+export { createLightSensor } from './primitives/create-light-sensor';
+export { createMagnetometer } from './primitives/create-magnetometer';
+export { createMagnetometerUncalibrated } from './primitives/create-magnetometer-uncalibrated';
+export { createPedometer } from './primitives/create-pedometer';
+export type { IUpdateIntervalMs } from './primitives/device-sensor-accessor';
+export * from '../core';