@symbiote-native/sensors 0.2.0 → 0.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@symbiote-native/sensors",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "expo-sensors wrapped for SymbioteNative — one framework-agnostic core, built once and reachable from the React, Vue, and Angular adapters. Accelerometer, Barometer, DeviceMotion, Gyroscope, LightSensor, Magnetometer, MagnetometerUncalibrated, Pedometer.",
   "license": "MIT",
   "repository": {
@@ -30,6 +30,10 @@
       "types": "./build/react/index.d.ts",
       "default": "./build/react/index.js"
     },
+    "./svelte": {
+      "types": "./build/svelte/index.d.ts",
+      "default": "./build/svelte/index.js"
+    },
     "./angular": {
       "types": "./build-ngc/angular/index.d.ts",
       "react-native": "./build-ngc/angular/index.js",
@@ -39,7 +43,11 @@
   "files": [
     "src",
     "build",
-    "build-ngc"
+    "build-ngc",
+    "native-link.json",
+    "!src/**/*.test.*",
+    "!src/**/*.spec.*",
+    "!src/**/*.detox.*"
   ],
   "publishConfig": {
     "access": "public"
@@ -49,15 +57,17 @@
     "expo-modules-core": "57.0.5"
   },
   "peerDependencies": {
+    "@symbiote-native/angular": ">=0.6.2",
     "@symbiote-native/engine": ">=0.1.7",
+    "@symbiote-native/react": ">=0.2.8",
+    "@symbiote-native/svelte": ">=0.1.0",
+    "@symbiote-native/vue": ">=0.3.8",
     "@angular/core": ">=20",
     "@vue/runtime-core": "^3.5.13",
     "react": ">=19.0.0",
     "react-native": ">=0.86",
-    "vue": ">=3.5.0",
-    "@symbiote-native/angular": "0.6.1",
-    "@symbiote-native/react": "0.2.8",
-    "@symbiote-native/vue": "0.3.8"
+    "svelte": ">=5.56.0",
+    "vue": ">=3.5.0"
   },
   "peerDependenciesMeta": {
     "@symbiote-native/angular": {
@@ -66,6 +76,9 @@
     "@symbiote-native/react": {
       "optional": true
     },
+    "@symbiote-native/svelte": {
+      "optional": true
+    },
     "@symbiote-native/vue": {
       "optional": true
     },
@@ -78,24 +91,29 @@
     "react": {
       "optional": true
     },
+    "svelte": {
+      "optional": true
+    },
     "vue": {
       "optional": true
     }
   },
   "devDependencies": {
-    "@angular/compiler": "^22",
-    "@angular/compiler-cli": "^22",
-    "@angular/core": "^22",
+    "@angular/compiler": "~22.0.8",
+    "@angular/compiler-cli": "~22.0.8",
+    "@angular/core": "~22.0.8",
     "@types/node": "^26.0.0",
     "@types/react": "^19.2.0",
     "@vue/runtime-core": "^3.5.13",
     "react": "19.2.3",
+    "svelte": "^5.56.0",
     "typescript": "~6.0.0",
-    "@symbiote-native/angular": "0.6.1",
-    "@symbiote-native/engine": "0.1.7",
-    "@symbiote-native/react": "0.2.8",
+    "@symbiote-native/angular": "0.7.0",
+    "@symbiote-native/engine": "0.2.0",
+    "@symbiote-native/react": "0.3.0",
+    "@symbiote-native/svelte": "0.2.0",
     "@symbiote-native/test-utils": "0.1.6",
-    "@symbiote-native/vue": "0.3.8"
+    "@symbiote-native/vue": "0.4.0"
   },
   "scripts": {
     "typecheck": "tsc --build",

package/src/angular/services/accelerometer.service/index.ts

@@ -1,23 +1,16 @@
 import { effect, inject, Injectable, Injector, signal, type Signal } from '@angular/core';
 import { Accelerometer, type IAccelerometerMeasurement } from '../../../core';
 
-// 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.
 @Injectable({ providedIn: 'root' })
 export class AccelerometerService {
-  // 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.
   private readonly injector = inject(Injector);
 
   connect(updateIntervalMs?: number): Signal<IAccelerometerMeasurement | null> {
@@ -25,6 +18,8 @@ export class AccelerometerService {
 
     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/src/angular/services/barometer.service/index.ts

@@ -1,23 +1,16 @@
 import { effect, inject, Injectable, Injector, signal, type Signal } from '@angular/core';
 import { Barometer, type IBarometerMeasurement } from '../../../core';
 
-// 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.
 @Injectable({ providedIn: 'root' })
 export class BarometerService {
-  // 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.
   private readonly injector = inject(Injector);
 
   connect(updateIntervalMs?: number): Signal<IBarometerMeasurement | null> {
@@ -25,6 +18,8 @@ export class BarometerService {
 
     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/src/angular/services/device-motion.service/index.ts

@@ -1,23 +1,16 @@
 import { effect, inject, Injectable, Injector, signal, type Signal } from '@angular/core';
 import { DeviceMotion, type IDeviceMotionMeasurement } from '../../../core';
 
-// 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.
 @Injectable({ providedIn: 'root' })
 export class DeviceMotionService {
-  // 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.
   private readonly injector = inject(Injector);
 
   connect(updateIntervalMs?: number): Signal<IDeviceMotionMeasurement | null> {
@@ -25,6 +18,8 @@ export class DeviceMotionService {
 
     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/src/angular/services/gyroscope.service/index.ts

@@ -1,23 +1,16 @@
 import { effect, inject, Injectable, Injector, signal, type Signal } from '@angular/core';
 import { Gyroscope, type IGyroscopeMeasurement } from '../../../core';
 
-// 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.
 @Injectable({ providedIn: 'root' })
 export class GyroscopeService {
-  // 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.
   private readonly injector = inject(Injector);
 
   connect(updateIntervalMs?: number): Signal<IGyroscopeMeasurement | null> {
@@ -25,6 +18,8 @@ export class GyroscopeService {
 
     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/src/angular/services/light-sensor.service/index.ts

@@ -1,23 +1,16 @@
 import { effect, inject, Injectable, Injector, signal, type Signal } from '@angular/core';
 import { LightSensor, type ILightSensorMeasurement } from '../../../core';
 
-// 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.
 @Injectable({ providedIn: 'root' })
 export class LightSensorService {
-  // 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.
   private readonly injector = inject(Injector);
 
   connect(updateIntervalMs?: number): Signal<ILightSensorMeasurement | null> {
@@ -25,6 +18,8 @@ export class LightSensorService {
 
     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/src/angular/services/magnetometer-uncalibrated.service/index.ts

@@ -1,23 +1,17 @@
 import { effect, inject, Injectable, Injector, signal, type Signal } from '@angular/core';
 import { MagnetometerUncalibrated, type IMagnetometerUncalibratedMeasurement } from '../../../core';
 
-// 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.
 @Injectable({ providedIn: 'root' })
 export class MagnetometerUncalibratedService {
-  // 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.
   private readonly injector = inject(Injector);
 
   connect(updateIntervalMs?: number): Signal<IMagnetometerUncalibratedMeasurement | null> {
@@ -25,6 +19,8 @@ export class MagnetometerUncalibratedService {
 
     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/src/angular/services/magnetometer.service/index.ts

@@ -1,23 +1,16 @@
 import { effect, inject, Injectable, Injector, signal, type Signal } from '@angular/core';
 import { Magnetometer, type IMagnetometerMeasurement } from '../../../core';
 
-// 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.
 @Injectable({ providedIn: 'root' })
 export class MagnetometerService {
-  // 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.
   private readonly injector = inject(Injector);
 
   connect(updateIntervalMs?: number): Signal<IMagnetometerMeasurement | null> {
@@ -25,6 +18,8 @@ export class MagnetometerService {
 
     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/src/angular/services/pedometer.service/index.ts

@@ -1,21 +1,17 @@
 import { effect, inject, Injectable, Injector, signal, type Signal } from '@angular/core';
 import { watchStepCount, type IPedometerResult } from '../../../core';
 
-// 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.
 @Injectable({ providedIn: 'root' })
 export class PedometerService {
-  // 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.
   private readonly injector = inject(Injector);
 
   connect(): Signal<IPedometerResult | null> {

package/src/core/device-motion.ts

@@ -24,8 +24,8 @@ export enum DeviceMotionOrientation {
 
 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.
+  // than hardcoded — mirrors upstream's dual exposure as an instance property and this
+  // standalone export.
   readonly gravity: number = exponentDeviceMotion.Gravity;
 }
 
@@ -36,6 +36,5 @@ export const DeviceMotion = new DeviceMotionSensor(
   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: number = exponentDeviceMotion.Gravity;

package/src/svelte/index.ts

@@ -0,0 +1,29 @@
+// @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 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/src/svelte/runes/use-accelerometer.svelte.ts

@@ -0,0 +1,36 @@
+// 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, type EventSubscription, type IAccelerometerMeasurement } from '../../core';
+
+export function useAccelerometer(updateIntervalMs?: number): {
+  readonly current: IAccelerometerMeasurement | null;
+} {
+  let measurement = $state<IAccelerometerMeasurement | null>(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: EventSubscription = Accelerometer.addListener(next => {
+      measurement = next;
+    });
+    return () => subscription.remove();
+  });
+
+  return {
+    get current(): IAccelerometerMeasurement | null {
+      return measurement;
+    },
+  };
+}

package/src/svelte/runes/use-barometer.svelte.ts

@@ -0,0 +1,27 @@
+// 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, type EventSubscription, type IBarometerMeasurement } from '../../core';
+
+export function useBarometer(updateIntervalMs?: number): {
+  readonly current: IBarometerMeasurement | null;
+} {
+  let measurement = $state<IBarometerMeasurement | null>(null);
+
+  $effect(() => {
+    if (updateIntervalMs !== undefined) {
+      Barometer.setUpdateInterval(updateIntervalMs);
+    }
+    const subscription: EventSubscription = Barometer.addListener(next => {
+      measurement = next;
+    });
+    return () => subscription.remove();
+  });
+
+  return {
+    get current(): IBarometerMeasurement | null {
+      return measurement;
+    },
+  };
+}

package/src/svelte/runes/use-device-motion.svelte.ts

@@ -0,0 +1,27 @@
+// 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, type EventSubscription, type IDeviceMotionMeasurement } from '../../core';
+
+export function useDeviceMotion(updateIntervalMs?: number): {
+  readonly current: IDeviceMotionMeasurement | null;
+} {
+  let measurement = $state<IDeviceMotionMeasurement | null>(null);
+
+  $effect(() => {
+    if (updateIntervalMs !== undefined) {
+      DeviceMotion.setUpdateInterval(updateIntervalMs);
+    }
+    const subscription: EventSubscription = DeviceMotion.addListener(next => {
+      measurement = next;
+    });
+    return () => subscription.remove();
+  });
+
+  return {
+    get current(): IDeviceMotionMeasurement | null {
+      return measurement;
+    },
+  };
+}

package/src/svelte/runes/use-gyroscope.svelte.ts

@@ -0,0 +1,27 @@
+// 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, type EventSubscription, type IGyroscopeMeasurement } from '../../core';
+
+export function useGyroscope(updateIntervalMs?: number): {
+  readonly current: IGyroscopeMeasurement | null;
+} {
+  let measurement = $state<IGyroscopeMeasurement | null>(null);
+
+  $effect(() => {
+    if (updateIntervalMs !== undefined) {
+      Gyroscope.setUpdateInterval(updateIntervalMs);
+    }
+    const subscription: EventSubscription = Gyroscope.addListener(next => {
+      measurement = next;
+    });
+    return () => subscription.remove();
+  });
+
+  return {
+    get current(): IGyroscopeMeasurement | null {
+      return measurement;
+    },
+  };
+}

package/src/svelte/runes/use-light-sensor.svelte.ts

@@ -0,0 +1,27 @@
+// 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, type EventSubscription, type ILightSensorMeasurement } from '../../core';
+
+export function useLightSensor(updateIntervalMs?: number): {
+  readonly current: ILightSensorMeasurement | null;
+} {
+  let measurement = $state<ILightSensorMeasurement | null>(null);
+
+  $effect(() => {
+    if (updateIntervalMs !== undefined) {
+      LightSensor.setUpdateInterval(updateIntervalMs);
+    }
+    const subscription: EventSubscription = LightSensor.addListener(next => {
+      measurement = next;
+    });
+    return () => subscription.remove();
+  });
+
+  return {
+    get current(): ILightSensorMeasurement | null {
+      return measurement;
+    },
+  };
+}

package/src/svelte/runes/use-magnetometer-uncalibrated.svelte.ts

@@ -0,0 +1,31 @@
+// 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,
+  type EventSubscription,
+  type IMagnetometerUncalibratedMeasurement,
+} from '../../core';
+
+export function useMagnetometerUncalibrated(updateIntervalMs?: number): {
+  readonly current: IMagnetometerUncalibratedMeasurement | null;
+} {
+  let measurement = $state<IMagnetometerUncalibratedMeasurement | null>(null);
+
+  $effect(() => {
+    if (updateIntervalMs !== undefined) {
+      MagnetometerUncalibrated.setUpdateInterval(updateIntervalMs);
+    }
+    const subscription: EventSubscription = MagnetometerUncalibrated.addListener(next => {
+      measurement = next;
+    });
+    return () => subscription.remove();
+  });
+
+  return {
+    get current(): IMagnetometerUncalibratedMeasurement | null {
+      return measurement;
+    },
+  };
+}