@symbiote-native/sensors 0.2.0 → 0.3.0

package/README.md

@@ -38,8 +38,8 @@ package with zero further changes:
 
 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
-`symbiote-expo-native-module` skill. Reference implementation: `.examples/react/ios/Podfile` and
-`.examples/react/android/app/src/main/java/com/canary/MainApplication.kt`.
+`symbiote-expo-native-module` skill. Reference implementation: `examples/expo-react/ios/Podfile`
+and `examples/expo-react/android/app/src/main/java/com/canaryexpo/MainApplication.kt`.
 
 Permissions ship with the native module itself — nothing to reimplement, just the platform
 permission string each sensor needs (e.g. DeviceMotion/Pedometer need `NSMotionUsageDescription`
@@ -99,9 +99,9 @@ export class SensorsScreen {
 }
 ```
 
-The React example above mirrors the real demo screen, `.examples/react/screens/SensorsScreen.tsx`
-— the Vue and Angular snippets are illustrative; those adapters' own demo screens aren't wired up
-yet (React is this repo's "prove the pattern first" adapter for this package).
+All three 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

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

@@ -34,18 +34,12 @@ var __runInitializers = (this && this.__runInitializers) || function (thisArg, i
 };
 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

@@ -34,18 +34,12 @@ var __runInitializers = (this && this.__runInitializers) || function (thisArg, i
 };
 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

@@ -34,18 +34,12 @@ var __runInitializers = (this && this.__runInitializers) || function (thisArg, i
 };
 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

@@ -34,18 +34,12 @@ var __runInitializers = (this && this.__runInitializers) || function (thisArg, i
 };
 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

@@ -34,18 +34,12 @@ var __runInitializers = (this && this.__runInitializers) || function (thisArg, i
 };
 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

@@ -34,18 +34,13 @@ var __runInitializers = (this && this.__runInitializers) || function (thisArg, i
 };
 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).
+// 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

@@ -34,18 +34,12 @@ var __runInitializers = (this && this.__runInitializers) || function (thisArg, i
 };
 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

@@ -34,16 +34,13 @@ var __runInitializers = (this && this.__runInitializers) || function (thisArg, i
 };
 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/svelte/index.d.ts

@@ -0,0 +1,16 @@
+export { useAccelerometer } from './runes/use-accelerometer.svelte';
+export type { IAccelerometerMeasurement } from '../core';
+export { useBarometer } from './runes/use-barometer.svelte';
+export type { IBarometerMeasurement } from '../core';
+export { useDeviceMotion } from './runes/use-device-motion.svelte';
+export { DeviceMotionOrientation, gravity, type IDeviceMotionMeasurement } from '../core';
+export { useGyroscope } from './runes/use-gyroscope.svelte';
+export type { IGyroscopeMeasurement } from '../core';
+export { useLightSensor } from './runes/use-light-sensor.svelte';
+export type { ILightSensorMeasurement } from '../core';
+export { useMagnetometer } from './runes/use-magnetometer.svelte';
+export type { IMagnetometerMeasurement } from '../core';
+export { useMagnetometerUncalibrated } from './runes/use-magnetometer-uncalibrated.svelte';
+export type { IMagnetometerUncalibratedMeasurement } from '../core';
+export { usePedometer } from './runes/use-pedometer.svelte';
+export { watchStepCount, getStepCountAsync, isAvailableAsync, getPermissionsAsync, requestPermissionsAsync, type IPedometerResult, type IPedometerUpdateCallback, } from '../core';

package/build/svelte/index.js

@@ -0,0 +1,14 @@
+// @symbiote-native/sensors/svelte: the Svelte entry over the framework-agnostic core.
+// useAccelerometer wires the Accelerometer singleton's addListener lifecycle onto Svelte's own
+// `$effect` (runes/use-accelerometer.svelte.ts) — mirrors the lifecycle-bucket naming convention
+// of adapters/svelte/src/runes (never `hooks/`/`composables/`, those are React's and Vue's terms).
+export { useAccelerometer } from './runes/use-accelerometer.svelte';
+export { useBarometer } from './runes/use-barometer.svelte';
+export { useDeviceMotion } from './runes/use-device-motion.svelte';
+export { DeviceMotionOrientation, gravity } from '../core/index.js';
+export { useGyroscope } from './runes/use-gyroscope.svelte';
+export { useLightSensor } from './runes/use-light-sensor.svelte';
+export { useMagnetometer } from './runes/use-magnetometer.svelte';
+export { useMagnetometerUncalibrated } from './runes/use-magnetometer-uncalibrated.svelte';
+export { usePedometer } from './runes/use-pedometer.svelte';
+export { watchStepCount, getStepCountAsync, isAvailableAsync, getPermissionsAsync, requestPermissionsAsync, } from '../core/index.js';

package/build/svelte/runes/use-accelerometer.svelte.d.ts

@@ -0,0 +1,4 @@
+import { type IAccelerometerMeasurement } from '../../core';
+export declare function useAccelerometer(updateIntervalMs?: number): {
+    readonly current: IAccelerometerMeasurement | null;
+};

package/build/svelte/runes/use-accelerometer.svelte.js

@@ -0,0 +1,31 @@
+// Svelte lifecycle wiring over the framework-agnostic Accelerometer singleton (core/).
+// `.svelte.ts` (not `.ts`): runes ($state/$effect) only work in files with this extension
+// outside an actual `.svelte` component; `runes/` is the framework's own lifecycle-bucket term
+// (CLAUDE.md's <adapter_src_follows_framework_idioms>).
+//
+// Returns a boxed getter, not a bare `$state`: Svelte 5 reactivity is lexically scoped to the
+// declaring module and doesn't survive being returned as a raw value, so callers read `.current`
+// like unwrapping Vue's `Ref.value`.
+//
+// `updateIntervalMs` is a plain number, not a getter: it applies once at subscribe time and
+// never reacts to a later change, matching the Vue/React twins.
+import { Accelerometer } from '../../core/index.js';
+export function useAccelerometer(updateIntervalMs) {
+    let measurement = $state(null);
+    $effect(() => {
+        if (updateIntervalMs !== undefined) {
+            Accelerometer.setUpdateInterval(updateIntervalMs);
+        }
+        // `measurement` is only ever written here, never read, so the effect has an empty dependency
+        // set and runs exactly once on mount, cleaning up exactly once on unmount.
+        const subscription = Accelerometer.addListener(next => {
+            measurement = next;
+        });
+        return () => subscription.remove();
+    });
+    return {
+        get current() {
+            return measurement;
+        },
+    };
+}

package/build/svelte/runes/use-barometer.svelte.d.ts

@@ -0,0 +1,4 @@
+import { type IBarometerMeasurement } from '../../core';
+export declare function useBarometer(updateIntervalMs?: number): {
+    readonly current: IBarometerMeasurement | null;
+};

package/build/svelte/runes/use-barometer.svelte.js

@@ -0,0 +1,22 @@
+// Svelte lifecycle wiring over the framework-agnostic Barometer singleton (core/) — mirrors
+// use-accelerometer.svelte.ts's shape exactly. See its header for why this lives in `runes/` with
+// a `.svelte.ts` extension, returns a boxed getter object, and takes a plain `updateIntervalMs`
+// rather than a getter.
+import { Barometer } from '../../core/index.js';
+export function useBarometer(updateIntervalMs) {
+    let measurement = $state(null);
+    $effect(() => {
+        if (updateIntervalMs !== undefined) {
+            Barometer.setUpdateInterval(updateIntervalMs);
+        }
+        const subscription = Barometer.addListener(next => {
+            measurement = next;
+        });
+        return () => subscription.remove();
+    });
+    return {
+        get current() {
+            return measurement;
+        },
+    };
+}

package/build/svelte/runes/use-device-motion.svelte.d.ts

@@ -0,0 +1,4 @@
+import { type IDeviceMotionMeasurement } from '../../core';
+export declare function useDeviceMotion(updateIntervalMs?: number): {
+    readonly current: IDeviceMotionMeasurement | null;
+};

package/build/svelte/runes/use-device-motion.svelte.js

@@ -0,0 +1,22 @@
+// Svelte lifecycle wiring over the framework-agnostic DeviceMotion singleton (core/) — mirrors
+// use-accelerometer.svelte.ts's shape exactly. See its header for why this lives in `runes/` with
+// a `.svelte.ts` extension, returns a boxed getter object, and takes a plain `updateIntervalMs`
+// rather than a getter.
+import { DeviceMotion } from '../../core/index.js';
+export function useDeviceMotion(updateIntervalMs) {
+    let measurement = $state(null);
+    $effect(() => {
+        if (updateIntervalMs !== undefined) {
+            DeviceMotion.setUpdateInterval(updateIntervalMs);
+        }
+        const subscription = DeviceMotion.addListener(next => {
+            measurement = next;
+        });
+        return () => subscription.remove();
+    });
+    return {
+        get current() {
+            return measurement;
+        },
+    };
+}

package/build/svelte/runes/use-gyroscope.svelte.d.ts

@@ -0,0 +1,4 @@
+import { type IGyroscopeMeasurement } from '../../core';
+export declare function useGyroscope(updateIntervalMs?: number): {
+    readonly current: IGyroscopeMeasurement | null;
+};

package/build/svelte/runes/use-gyroscope.svelte.js

@@ -0,0 +1,22 @@
+// Svelte lifecycle wiring over the framework-agnostic Gyroscope singleton (core/) — mirrors
+// use-accelerometer.svelte.ts's shape exactly. See its header for why this lives in `runes/` with
+// a `.svelte.ts` extension, returns a boxed getter object, and takes a plain `updateIntervalMs`
+// rather than a getter.
+import { Gyroscope } from '../../core/index.js';
+export function useGyroscope(updateIntervalMs) {
+    let measurement = $state(null);
+    $effect(() => {
+        if (updateIntervalMs !== undefined) {
+            Gyroscope.setUpdateInterval(updateIntervalMs);
+        }
+        const subscription = Gyroscope.addListener(next => {
+            measurement = next;
+        });
+        return () => subscription.remove();
+    });
+    return {
+        get current() {
+            return measurement;
+        },
+    };
+}

package/build/svelte/runes/use-light-sensor.svelte.d.ts

@@ -0,0 +1,4 @@
+import { type ILightSensorMeasurement } from '../../core';
+export declare function useLightSensor(updateIntervalMs?: number): {
+    readonly current: ILightSensorMeasurement | null;
+};

package/build/svelte/runes/use-light-sensor.svelte.js

@@ -0,0 +1,22 @@
+// Svelte lifecycle wiring over the framework-agnostic LightSensor singleton (core/) — mirrors
+// use-accelerometer.svelte.ts's shape exactly. See its header for why this lives in `runes/` with
+// a `.svelte.ts` extension, returns a boxed getter object, and takes a plain `updateIntervalMs`
+// rather than a getter.
+import { LightSensor } from '../../core/index.js';
+export function useLightSensor(updateIntervalMs) {
+    let measurement = $state(null);
+    $effect(() => {
+        if (updateIntervalMs !== undefined) {
+            LightSensor.setUpdateInterval(updateIntervalMs);
+        }
+        const subscription = LightSensor.addListener(next => {
+            measurement = next;
+        });
+        return () => subscription.remove();
+    });
+    return {
+        get current() {
+            return measurement;
+        },
+    };
+}

package/build/svelte/runes/use-magnetometer-uncalibrated.svelte.d.ts

@@ -0,0 +1,4 @@
+import { type IMagnetometerUncalibratedMeasurement } from '../../core';
+export declare function useMagnetometerUncalibrated(updateIntervalMs?: number): {
+    readonly current: IMagnetometerUncalibratedMeasurement | null;
+};

package/build/svelte/runes/use-magnetometer-uncalibrated.svelte.js

@@ -0,0 +1,22 @@
+// Svelte lifecycle wiring over the framework-agnostic MagnetometerUncalibrated singleton (core/) —
+// mirrors use-accelerometer.svelte.ts's shape exactly. See its header for why this lives in
+// `runes/` with a `.svelte.ts` extension, returns a boxed getter object, and takes a plain
+// `updateIntervalMs` rather than a getter.
+import { MagnetometerUncalibrated, } from '../../core/index.js';
+export function useMagnetometerUncalibrated(updateIntervalMs) {
+    let measurement = $state(null);
+    $effect(() => {
+        if (updateIntervalMs !== undefined) {
+            MagnetometerUncalibrated.setUpdateInterval(updateIntervalMs);
+        }
+        const subscription = MagnetometerUncalibrated.addListener(next => {
+            measurement = next;
+        });
+        return () => subscription.remove();
+    });
+    return {
+        get current() {
+            return measurement;
+        },
+    };
+}

package/build/svelte/runes/use-magnetometer.svelte.d.ts

@@ -0,0 +1,4 @@
+import { type IMagnetometerMeasurement } from '../../core';
+export declare function useMagnetometer(updateIntervalMs?: number): {
+    readonly current: IMagnetometerMeasurement | null;
+};

package/build/svelte/runes/use-magnetometer.svelte.js

@@ -0,0 +1,22 @@
+// Svelte lifecycle wiring over the framework-agnostic Magnetometer singleton (core/) — mirrors
+// use-accelerometer.svelte.ts's shape exactly. See its header for why this lives in `runes/` with
+// a `.svelte.ts` extension, returns a boxed getter object, and takes a plain `updateIntervalMs`
+// rather than a getter.
+import { Magnetometer } from '../../core/index.js';
+export function useMagnetometer(updateIntervalMs) {
+    let measurement = $state(null);
+    $effect(() => {
+        if (updateIntervalMs !== undefined) {
+            Magnetometer.setUpdateInterval(updateIntervalMs);
+        }
+        const subscription = Magnetometer.addListener(next => {
+            measurement = next;
+        });
+        return () => subscription.remove();
+    });
+    return {
+        get current() {
+            return measurement;
+        },
+    };
+}

package/build/svelte/runes/use-pedometer.svelte.d.ts

@@ -0,0 +1,4 @@
+import { type IPedometerResult } from '../../core';
+export declare function usePedometer(): {
+    readonly current: IPedometerResult | null;
+};