@symbiote-native/sensors 0.3.0 → 1.0.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,7 +32,7 @@ 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 / Vue's `useAccelerometer` composable.
 // Angular has no per-instance hook, so `connect()` stands in: call it ONCE, inside an injection

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

@@ -32,7 +32,7 @@ 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 / Vue's `useBarometer` composable. Angular has no
 // per-instance hook, so `connect()` stands in: call it ONCE, inside an injection context

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

@@ -32,7 +32,7 @@ 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 / Vue's `useDeviceMotion` composable. Angular
 // has no per-instance hook, so `connect()` stands in: call it ONCE, inside an injection context

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

@@ -32,7 +32,7 @@ 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 / Vue's `useGyroscope` composable. Angular has no
 // per-instance hook, so `connect()` stands in: call it ONCE, inside an injection context

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

@@ -32,7 +32,7 @@ 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 / Vue's `useLightSensor` composable. Angular
 // has no per-instance hook, so `connect()` stands in: call it ONCE, inside an injection context

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

@@ -32,8 +32,8 @@ 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';
+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

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

@@ -32,7 +32,7 @@ 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 / Vue's `useMagnetometer` composable. Angular
 // has no per-instance hook, so `connect()` stands in: call it ONCE, inside an injection context

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

@@ -32,7 +32,7 @@ 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 / Vue's `usePedometer` composable. Angular has no
 // per-instance hook, so `connect()` stands in: call it ONCE, inside an injection context

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';

package/build/solid/index.js

@@ -0,0 +1,17 @@
+// @symbiote-native/sensors/solid: the Solid entry over the framework-agnostic core.
+// createAccelerometer wires the Accelerometer singleton's addListener lifecycle onto Solid's own
+// signal + onCleanup (primitives/create-accelerometer) — `primitives/` and `create*` are Solid's
+// terms for a composable reactive function, never `hooks/`/`composables/`/`runes/`, which are
+// React's, Vue's and Svelte's. Same convention as adapters/solid/src/primitives.
+//
+// Every primitive returns an `Accessor`, and each DeviceSensor-shaped one takes its update
+// interval as a number OR an accessor — see primitives/device-sensor-accessor for why.
+export { createAccelerometer } from './primitives/create-accelerometer.js';
+export { createBarometer } from './primitives/create-barometer.js';
+export { createDeviceMotion } from './primitives/create-device-motion.js';
+export { createGyroscope } from './primitives/create-gyroscope.js';
+export { createLightSensor } from './primitives/create-light-sensor.js';
+export { createMagnetometer } from './primitives/create-magnetometer.js';
+export { createMagnetometerUncalibrated } from './primitives/create-magnetometer-uncalibrated.js';
+export { createPedometer } from './primitives/create-pedometer.js';
+export * from '../core/index.js';

package/build/solid/primitives/create-accelerometer.d.ts

@@ -0,0 +1,4 @@
+import type { Accessor } from 'solid-js';
+import { type IAccelerometerMeasurement } from '../../core';
+import { type IUpdateIntervalMs } from './device-sensor-accessor';
+export declare function createAccelerometer(updateIntervalMs?: IUpdateIntervalMs): Accessor<IAccelerometerMeasurement | null>;

package/build/solid/primitives/create-accelerometer.js

@@ -0,0 +1,5 @@
+import { Accelerometer } from '../../core/index.js';
+import { createDeviceSensorAccessor, } from './device-sensor-accessor.js';
+export function createAccelerometer(updateIntervalMs) {
+    return createDeviceSensorAccessor(Accelerometer, updateIntervalMs);
+}

package/build/solid/primitives/create-barometer.d.ts

@@ -0,0 +1,4 @@
+import type { Accessor } from 'solid-js';
+import { type IBarometerMeasurement } from '../../core';
+import { type IUpdateIntervalMs } from './device-sensor-accessor';
+export declare function createBarometer(updateIntervalMs?: IUpdateIntervalMs): Accessor<IBarometerMeasurement | null>;

package/build/solid/primitives/create-barometer.js

@@ -0,0 +1,5 @@
+import { Barometer } from '../../core/index.js';
+import { createDeviceSensorAccessor, } from './device-sensor-accessor.js';
+export function createBarometer(updateIntervalMs) {
+    return createDeviceSensorAccessor(Barometer, updateIntervalMs);
+}

package/build/solid/primitives/create-device-motion.d.ts

@@ -0,0 +1,4 @@
+import type { Accessor } from 'solid-js';
+import { type IDeviceMotionMeasurement } from '../../core';
+import { type IUpdateIntervalMs } from './device-sensor-accessor';
+export declare function createDeviceMotion(updateIntervalMs?: IUpdateIntervalMs): Accessor<IDeviceMotionMeasurement | null>;

package/build/solid/primitives/create-device-motion.js

@@ -0,0 +1,5 @@
+import { DeviceMotion } from '../../core/index.js';
+import { createDeviceSensorAccessor, } from './device-sensor-accessor.js';
+export function createDeviceMotion(updateIntervalMs) {
+    return createDeviceSensorAccessor(DeviceMotion, updateIntervalMs);
+}

package/build/solid/primitives/create-gyroscope.d.ts

@@ -0,0 +1,4 @@
+import type { Accessor } from 'solid-js';
+import { type IGyroscopeMeasurement } from '../../core';
+import { type IUpdateIntervalMs } from './device-sensor-accessor';
+export declare function createGyroscope(updateIntervalMs?: IUpdateIntervalMs): Accessor<IGyroscopeMeasurement | null>;

package/build/solid/primitives/create-gyroscope.js

@@ -0,0 +1,5 @@
+import { Gyroscope } from '../../core/index.js';
+import { createDeviceSensorAccessor, } from './device-sensor-accessor.js';
+export function createGyroscope(updateIntervalMs) {
+    return createDeviceSensorAccessor(Gyroscope, updateIntervalMs);
+}

package/build/solid/primitives/create-light-sensor.d.ts

@@ -0,0 +1,4 @@
+import type { Accessor } from 'solid-js';
+import { type ILightSensorMeasurement } from '../../core';
+import { type IUpdateIntervalMs } from './device-sensor-accessor';
+export declare function createLightSensor(updateIntervalMs?: IUpdateIntervalMs): Accessor<ILightSensorMeasurement | null>;

package/build/solid/primitives/create-light-sensor.js

@@ -0,0 +1,5 @@
+import { LightSensor } from '../../core/index.js';
+import { createDeviceSensorAccessor, } from './device-sensor-accessor.js';
+export function createLightSensor(updateIntervalMs) {
+    return createDeviceSensorAccessor(LightSensor, updateIntervalMs);
+}

package/build/solid/primitives/create-magnetometer-uncalibrated.d.ts

@@ -0,0 +1,4 @@
+import type { Accessor } from 'solid-js';
+import { type IMagnetometerUncalibratedMeasurement } from '../../core';
+import { type IUpdateIntervalMs } from './device-sensor-accessor';
+export declare function createMagnetometerUncalibrated(updateIntervalMs?: IUpdateIntervalMs): Accessor<IMagnetometerUncalibratedMeasurement | null>;

package/build/solid/primitives/create-magnetometer-uncalibrated.js

@@ -0,0 +1,5 @@
+import { MagnetometerUncalibrated, } from '../../core/index.js';
+import { createDeviceSensorAccessor, } from './device-sensor-accessor.js';
+export function createMagnetometerUncalibrated(updateIntervalMs) {
+    return createDeviceSensorAccessor(MagnetometerUncalibrated, updateIntervalMs);
+}

package/build/solid/primitives/create-magnetometer.d.ts

@@ -0,0 +1,4 @@
+import type { Accessor } from 'solid-js';
+import { type IMagnetometerMeasurement } from '../../core';
+import { type IUpdateIntervalMs } from './device-sensor-accessor';
+export declare function createMagnetometer(updateIntervalMs?: IUpdateIntervalMs): Accessor<IMagnetometerMeasurement | null>;

package/build/solid/primitives/create-magnetometer.js

@@ -0,0 +1,5 @@
+import { Magnetometer } from '../../core/index.js';
+import { createDeviceSensorAccessor, } from './device-sensor-accessor.js';
+export function createMagnetometer(updateIntervalMs) {
+    return createDeviceSensorAccessor(Magnetometer, updateIntervalMs);
+}

package/build/solid/primitives/create-pedometer.d.ts

@@ -0,0 +1,3 @@
+import { type Accessor } from 'solid-js';
+import { type IPedometerResult } from '../../core';
+export declare function createPedometer(): Accessor<IPedometerResult | null>;

package/build/solid/primitives/create-pedometer.js

@@ -0,0 +1,22 @@
+// Solid lifecycle wiring over the framework-agnostic watchStepCount free function (core/) — the
+// Solid twin of react/hooks/use-pedometer, vue/composables/use-pedometer and
+// svelte/runes/use-pedometer.svelte.ts. Pedometer is the one sensor here that is not a
+// DeviceSensor subclass (core/pedometer.ts's header), so it has no setUpdateInterval and takes no
+// interval argument — hence its own body instead of ./device-sensor-accessor.
+//
+// `primitives/` and `create*`, and an ACCESSOR rather than a snapshot, for the reasons recorded in
+// adapters/solid/src/primitives/create-color-scheme.ts.
+import { createSignal, onCleanup } from 'solid-js';
+import { watchStepCount, } from '../../core/index.js';
+export function createPedometer() {
+    const [result, setResult] = createSignal(null);
+    // Subscribed from the primitive body, not from an effect: React/Vue/Svelte start listening a
+    // tick after their seed runs, so a step count landing in that window is lost.
+    const subscription = watchStepCount(next => {
+        setResult(next);
+    });
+    onCleanup(() => {
+        subscription.remove();
+    });
+    return result;
+}

package/build/solid/primitives/device-sensor-accessor.d.ts

@@ -0,0 +1,9 @@
+import { type Accessor } from 'solid-js';
+import type { EventSubscription, IListener } from '../../core';
+export type IUpdateIntervalMs = number | Accessor<number | undefined> | undefined;
+type ISensorHandle<Measurement> = {
+    addListener(listener: IListener<Measurement>): EventSubscription;
+    setUpdateInterval(intervalMs: number): void;
+};
+export declare function createDeviceSensorAccessor<Measurement>(sensor: ISensorHandle<Measurement>, updateIntervalMs?: IUpdateIntervalMs): Accessor<Measurement | null>;
+export {};

package/build/solid/primitives/device-sensor-accessor.js

@@ -0,0 +1,66 @@
+// The one lifecycle body every DeviceSensor-shaped primitive in this folder delegates to
+// (Accelerometer, Barometer, DeviceMotion, Gyroscope, LightSensor, Magnetometer,
+// MagnetometerUncalibrated). Internal — not re-exported from ../index.ts, whose surface stays at
+// parity with the react/vue/svelte entries.
+//
+// `primitives/` and `create*`, never `hooks/` + `use*`: Solid's ecosystem calls a composable
+// reactive function a PRIMITIVE and reserves `use*` for consuming something that already exists.
+// Full rationale in adapters/solid/src/primitives/create-color-scheme.ts.
+//
+// Returns an ACCESSOR, never a snapshot: a Solid component body runs ONCE, so a returned
+// measurement would pin the caller to `null` forever.
+//
+// ## Why the interval is `number | Accessor<number | undefined>`
+//
+// React re-reads `updateIntervalMs` on every render and re-runs its effect when it changes; Vue
+// and Svelte read it once at subscribe time. Neither shape ports: a Solid body runs once, so a
+// plain parameter freezes the sample rate at whatever the caller passed at mount, and nothing
+// reports it — the caller's `intervalMs` state moves and the native rate does not. So the
+// parameter accepts EITHER form (solid-primitives' `MaybeAccessor` convention): a literal for the
+// common static case, keeping the call site identical to the other adapters, or an accessor when
+// the rate is derived from state. The accessor form is the reactive one and is the only one that
+// creates an effect.
+//
+// Applying it splits in two on purpose. The mount-time value is applied SYNCHRONOUSLY, before
+// `addListener`, so the very first native sample already arrives at the requested rate; the
+// tracking effect is then `defer`red so it fires only on a LATER change. Without the defer the
+// interval would be set twice at mount, and the second call would land a tick after the first
+// samples.
+//
+// Outside a component or `createRoot` there is no owner for `onCleanup` — Solid warns and the
+// native listener lives for the process. The accessor still tracks; only the teardown is lost.
+import { createEffect, createSignal, on, onCleanup, untrack, } from 'solid-js';
+export function createDeviceSensorAccessor(sensor, updateIntervalMs) {
+    const [measurement, setMeasurement] = createSignal(null);
+    function applyInterval(intervalMs) {
+        // `!== undefined`, not truthiness: 0 is a legitimate "as fast as possible" rate, and an
+        // unconditional call would stomp the rate another consumer of this shared singleton set.
+        if (intervalMs !== undefined) {
+            sensor.setUpdateInterval(intervalMs);
+        }
+    }
+    // untracked: a primitive built inside a tracked scope must not re-run — and re-subscribe —
+    // just because it read the caller's interval accessor once.
+    applyInterval(untrack(() => typeof updateIntervalMs === 'function'
+        ? updateIntervalMs()
+        : updateIntervalMs));
+    // Subscribed from the primitive body, not from an effect: React/Vue/Svelte start listening a
+    // tick after their seed runs, so an event landing in that window is lost. Both statements here
+    // run in one synchronous tick and nothing can interleave.
+    const subscription = sensor.addListener(next => {
+        // The updater form, because `Measurement` is unconstrained — a bare value would be read as a
+        // reducer for any measurement type that could itself be callable.
+        setMeasurement(() => next);
+    });
+    onCleanup(() => {
+        subscription.remove();
+    });
+    if (typeof updateIntervalMs === 'function') {
+        // Only the rate changes — the native listener is per-sensor and unaffected, so re-subscribing
+        // (as React's interval-keyed effect does) would drop events for nothing.
+        createEffect(on(updateIntervalMs, intervalMs => {
+            applyInterval(intervalMs);
+        }, { defer: true }));
+    }
+    return measurement;
+}

package/build/svelte/index.d.ts

@@ -3,7 +3,7 @@ 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 { 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';

package/build/svelte/index.js

@@ -5,7 +5,7 @@
 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 { 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';

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

@@ -9,7 +9,7 @@
 //
 // `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';
+import { Accelerometer, } from '../../core/index.js';
 export function useAccelerometer(updateIntervalMs) {
     let measurement = $state(null);
     $effect(() => {

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

@@ -2,7 +2,7 @@
 // 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';
+import { Barometer, } from '../../core/index.js';
 export function useBarometer(updateIntervalMs) {
     let measurement = $state(null);
     $effect(() => {

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

@@ -2,7 +2,7 @@
 // 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';
+import { DeviceMotion, } from '../../core/index.js';
 export function useDeviceMotion(updateIntervalMs) {
     let measurement = $state(null);
     $effect(() => {

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

@@ -2,7 +2,7 @@
 // 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';
+import { Gyroscope, } from '../../core/index.js';
 export function useGyroscope(updateIntervalMs) {
     let measurement = $state(null);
     $effect(() => {