craft-native 0.0.436 → 0.0.442

package/LICENSE.md

@@ -19,3 +19,33 @@ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
+
+## Installer layout notices
+
+The Finder store and Carbon Alias format implementation follows the MIT-licensed
+references [gwend/dsstore](https://github.com/gwend/dsstore),
+[rigsmith/rigsmith](https://github.com/rigsmith/rigsmith/tree/main/core/dsstore), and
+[al45tair/mac_alias](https://github.com/al45tair/mac_alias).
+
+Copyright (c) 2020 Kenty Gwend
+Copyright (c) 2026 John Campion Jr
+Copyright (c) 2014 Alastair Houghton
+Copyright (c) 2022 Russell Keith-Magee
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -740,3 +740,38 @@ Craft's bundled-backend host reads `backend: { executable: 'stx-backend' }` from
 the helper with `--serve --managed`, and consumes its authenticated loopback URL.
 The helper's standard input is a lifetime lease: it must stop when that pipe
 closes. `craft --capabilities` advertises `bundleBackend` on macOS.
+
+## Drag-to-Applications disk images
+
+`createDiskImage` packages an existing macOS app bundle with an Applications
+shortcut, installation artwork and a Finder icon layout. The layout is written
+without launching Finder or requesting Automation permission.
+
+```ts
+import { createDiskImage } from 'craft-native'
+
+const image = await createDiskImage({
+  appBundlePath: './dist/Example.app',
+  outputPath: './dist/Example.dmg',
+  volumeName: 'Example',
+})
+if (!image.success) throw new Error(image.error)
+```
+
+Signing and notarization belong to the publishing pipeline. Stacks applications
+use Buddy and Pantry's native workflow to sign, notarize and staple the image
+before attaching its ZIP archive. Craft's updater accepts both app ZIPs and ZIPs
+containing a single DMG, and verifies the extracted app before installation.
+
+The shipped LICENSE file includes the installer layout's third-party notices.
+
+## Framework bridge types
+
+Core owns the optional `Window.craft` declaration. React, Svelte and Vue bindings
+depend on core for types, so importing a binding alongside `craft-native` does
+not redeclare that global with an incompatible shape.
+
+`CraftBindingsAPI` describes the bindings' existing flat host API (`getPlatform`,
+`invoke`, and related methods). Their hooks and stores retain that view and their
+runtime behavior. This type does not install a bridge, add flat methods to a
+desktop host, or replace the structured `CraftBridgeAPI` and typed event APIs.

package/dist/android/src/index.d.ts

@@ -7,6 +7,8 @@ export type { AndroidMapProvider } from './native-map.js';
  * well as the one-file bundle, and the app runs each screen from its own
  * route's file. Stacks asks for route bundles only when this is true.
  */
+/** Build-time proof for Stacks capability mappings, including unreleased source builds. */
+export declare const nativeSensorCapabilities: readonly ['motionSensors', 'barometer', 'pedometer'];
 export declare const nativeRouteBundles = true;
 /**
  * The app evaluates stx's shared runtime (`__runtime.js`, stx's
@@ -65,6 +67,12 @@ export interface CraftAndroidConfig {
     enableSecureStorage?: boolean;
     enableGeolocation?: boolean;
     enableBackgroundLocation?: boolean;
+    /** Foreground raw Android sensors on native screens; separate from iOS fused motion. */
+    enableMotionSensors?: boolean;
+    /** Foreground pressure and session-relative altitude; does not enable background recording. */
+    enableBarometer?: boolean;
+    /** Foreground hardware step counters/detectors; requires activity recognition on Android 10+. */
+    enablePedometer?: boolean;
     enableBluetooth?: boolean;
     /**
      * A Bluetooth heart-rate strap, or a watch broadcasting its heart rate (the

package/dist/android/src/index.js

@@ -549,6 +549,7 @@ function compressNativeSources(target) {
   if (packed.length < bytes.length)
     writeFileSync(target, packed);
 }
+var nativeSensorCapabilities = ["motionSensors", "barometer", "pedometer"];
 var nativeRouteBundles = true;
 var nativeRouteRuntime = true;
 var nativeMessages = true;
@@ -715,6 +716,9 @@ var DEFAULT_CONFIG = {
   enableSecureStorage: false,
   enableGeolocation: false,
   enableBackgroundLocation: false,
+  enableMotionSensors: false,
+  enableBarometer: false,
+  enablePedometer: false,
   enableBluetooth: false,
   enableHeartRate: false,
   enableHealthConnect: false,
@@ -1013,10 +1017,14 @@ function renderAndroidPermissions(config) {
   }
   if (config.enablePushNotifications)
     permissions.add("android.permission.POST_NOTIFICATIONS");
-  if (config.enableKeepAwake)
+  if (config.enableKeepAwake || config.enableBarometer && config.enableBackgroundLocation)
     permissions.add("android.permission.WAKE_LOCK");
   if (config.enableHealthConnect)
     healthConnectPermissions(config).forEach((permission) => permissions.add(permission));
+  if (config.enablePedometer)
+    permissions.add("android.permission.ACTIVITY_RECOGNITION");
+  if (config.enablePedometer && config.enableHealthServices)
+    permissions.add("android.permission.RECEIVE_BOOT_COMPLETED");
   if (config.renderer === "native" && config.backgroundRefresh?.enabled)
     permissions.add("android.permission.RECEIVE_BOOT_COMPLETED");
   if (config.enableHeartRate) {
@@ -1056,13 +1064,16 @@ function writeNativeShellSources(output, packagePath, packageName, config) {
   write("CraftSnapshotFile.kt.template", "CraftSnapshotFile.kt");
   write("CraftNativeImageCache.kt.template", "CraftNativeImageCache.kt");
   write("CraftNativeHaptics.kt.template", "CraftNativeHaptics.kt");
+  write("CraftNativeMotion.kt.template", "CraftNativeMotion.kt");
   write("CraftNativeBackground.kt.template", "CraftNativeBackground.kt");
   write(config.enableHealthConnect ? "CraftNativeHealth.kt.template" : "CraftNativeHealthStub.kt.template", "CraftNativeHealth.kt");
   write(config.enableHealthServices ? "CraftHealthServices.kt.template" : "CraftHealthServicesStub.kt.template", "CraftHealthServices.kt");
   if (config.enableHealthServices) {
     write("CraftHealthServicesService.kt.template", "CraftHealthServicesService.kt");
+    write("CraftPassiveSteps.kt.template", "CraftPassiveSteps.kt");
   } else {
     rmSync2(join3(javaDir, "CraftHealthServicesService.kt"), { force: true });
+    rmSync2(join3(javaDir, "CraftPassiveSteps.kt"), { force: true });
   }
   write("CraftNativeServices.kt.template", "CraftNativeServices.kt", (source) => source.replace("{{NATIVE_PUSH_IMPORTS}}", config.enablePushNotifications ? "import com.google.firebase.messaging.FirebaseMessaging" : "").replace("{{NATIVE_WALLET_IMPORTS}}", config.enableWallet ? `import com.google.android.gms.pay.Pay
 import com.google.android.gms.pay.PayApiAvailabilityStatus
@@ -1348,6 +1359,7 @@ async function init(options) {
   const nativeDir = join3(output, "app/src/main/java/com/craft/runtime");
   mkdirSync2(nativeDir, { recursive: true });
   writeFileSync(join3(nativeDir, "CraftNative.kt"), craftNative);
+  writeFileSync(join3(nativeDir, "CraftRecordingPressure.kt"), readFileSync2(join3(TEMPLATES_DIR, "CraftRecordingPressure.kt.template"), "utf-8"));
   const serviceTemplate = readFileSync2(join3(TEMPLATES_DIR, "LocationRecordingService.kt.template"), "utf-8");
   writeFileSync(join3(nativeDir, "LocationRecordingService.kt"), serviceTemplate.replace(/\{\{PACKAGE_NAME\}\}/g, finalPackageName));
   const healthTemplate = readFileSync2(join3(TEMPLATES_DIR, config.enableHealthConnect ? "CraftHealthConnect.kt.template" : "CraftHealthConnectStub.kt.template"), "utf-8");
@@ -1356,7 +1368,9 @@ async function init(options) {
     writeFileSync(join3(output, "app/src/main/java", packagePath, file), readFileSync2(join3(TEMPLATES_DIR, template), "utf8").replace(/\{\{PACKAGE_NAME\}\}/g, finalPackageName));
   }
   const manifestTemplate = readFileSync2(join3(TEMPLATES_DIR, "AndroidManifest.xml.template"), "utf-8");
-  const manifest = manifestTemplate.replace(/\{\{PACKAGE_NAME\}\}/g, finalPackageName).replace(/\{\{APP_NAME\}\}/g, name).replace(/\{\{PERMISSIONS\}\}/g, renderAndroidPermissions(config)).replace(/\{\{USES_CLEARTEXT\}\}/g, config.devServerURL?.startsWith("http://") || config.enableLocalNetwork ? "true" : "false").replace(/\{\{DEEP_LINK_INTENT_FILTERS\}\}/g, renderAndroidDeepLinks(config)).replace(/\{\{BACKGROUND_SERVICE\}\}/g, config.enableBackgroundLocation ? '        <service android:name="com.craft.runtime.LocationRecordingService" android:exported="false" android:foregroundServiceType="location" android:stopWithTask="false" />' : "").replace(/\{\{HEART_RATE_SERVICE\}\}/g, config.enableHeartRate ? '        <service android:name=".CraftHeartRateService" android:exported="false" android:foregroundServiceType="connectedDevice" />' : "").replace(/\{\{HEALTH_SERVICES_SERVICE\}\}/g, config.enableHealthServices ? '        <service android:name=".CraftHealthServicesService" android:exported="false" android:foregroundServiceType="health" android:stopWithTask="false" />' : "").replace(/\{\{NATIVE_NOTIFICATION_RECEIVER\}\}/g, config.renderer === "native" ? renderNativeShellManifest(config) : "").replace(/\{\{CRASH_REPORTER_PROVIDER\}\}/g, `        <provider android:name=".CraftCrashReporterInit" android:authorities="\${applicationId}.craft-crash" android:exported="false" android:initOrder="1000" />`).replace(/\{\{GOOGLE_MAPS_API_KEY\}\}/g, config.mapProvider !== "maplibre" && config.mapsApiKey ? `        <meta-data android:name="com.google.android.geo.API_KEY" android:value="${escapeXml(config.mapsApiKey)}" />` : "").replace(/\{\{HEALTH_CONNECT_QUERIES\}\}/g, config.enableHealthConnect ? `    <queries>
+  const manifest = manifestTemplate.replace(/\{\{PACKAGE_NAME\}\}/g, finalPackageName).replace(/\{\{APP_NAME\}\}/g, name).replace(/\{\{PERMISSIONS\}\}/g, renderAndroidPermissions(config)).replace(/\{\{USES_CLEARTEXT\}\}/g, config.devServerURL?.startsWith("http://") || config.enableLocalNetwork ? "true" : "false").replace(/\{\{DEEP_LINK_INTENT_FILTERS\}\}/g, renderAndroidDeepLinks(config)).replace(/\{\{BACKGROUND_SERVICE\}\}/g, config.enableBackgroundLocation ? '        <service android:name="com.craft.runtime.LocationRecordingService" android:exported="false" android:foregroundServiceType="location" android:stopWithTask="false" />' : "").replace(/\{\{HEART_RATE_SERVICE\}\}/g, config.enableHeartRate ? '        <service android:name=".CraftHeartRateService" android:exported="false" android:foregroundServiceType="connectedDevice" />' : "").replace(/\{\{HEALTH_SERVICES_SERVICE\}\}/g, config.enableHealthServices ? '        <service android:name=".CraftHealthServicesService" android:exported="false" android:foregroundServiceType="health" android:stopWithTask="false" />' + (config.enablePedometer ? `
+        <service android:name=".CraftPassiveStepsService" android:exported="true" android:permission="com.google.android.wearable.healthservices.permission.PASSIVE_DATA_BINDING" />
+        <receiver android:name=".CraftPassiveStepsBootReceiver" android:exported="true"><intent-filter><action android:name="android.intent.action.BOOT_COMPLETED" /></intent-filter></receiver>` : "") : "").replace(/\{\{NATIVE_NOTIFICATION_RECEIVER\}\}/g, config.renderer === "native" ? renderNativeShellManifest(config) : "").replace(/\{\{CRASH_REPORTER_PROVIDER\}\}/g, `        <provider android:name=".CraftCrashReporterInit" android:authorities="\${applicationId}.craft-crash" android:exported="false" android:initOrder="1000" />`).replace(/\{\{GOOGLE_MAPS_API_KEY\}\}/g, config.mapProvider !== "maplibre" && config.mapsApiKey ? `        <meta-data android:name="com.google.android.geo.API_KEY" android:value="${escapeXml(config.mapsApiKey)}" />` : "").replace(/\{\{HEALTH_CONNECT_QUERIES\}\}/g, config.enableHealthConnect ? `    <queries>
         <package android:name="com.google.android.apps.healthdata" />
     </queries>` : "").replace(/\{\{HEALTH_CONNECT_RATIONALE\}\}/g, config.enableHealthConnect ? `            <intent-filter>
                 <action android:name="androidx.health.ACTION_SHOW_PERMISSIONS_RATIONALE" />
@@ -1704,6 +1718,7 @@ export {
   nativeMessages,
   nativeRouteBundles,
   nativeRouteRuntime,
+  nativeSensorCapabilities,
   open,
   renderAndroidDeepLinks,
   renderAndroidPermissions,

package/dist/android/templates/CraftHealthServices.kt.template

@@ -20,9 +20,11 @@ internal class CraftHealthServices(
     private val activityProvider: () -> Activity?,
     private val fallback: ((String, JSONArray, (CraftNativeCapabilityResult) -> Unit) -> Unit)? = null,
 ) {
+    private val passiveSteps by lazy { CraftPassiveSteps(context) }
     private fun failure(code: String, message: String) = CraftNativeCapabilityResult(code = code, message = message)
 
     fun perform(method: String, args: JSONArray, done: (CraftNativeCapabilityResult) -> Unit) {
+        if (method.startsWith("passive:")) { passiveSteps.perform(method.removePrefix("passive:"), done); return }
         when (method) {
             "startWorkout" -> start(args.optJSONObject(0) ?: JSONObject(), done)
             "pauseWorkout" -> command(CraftHealthServicesService.ACTION_PAUSE, done)

package/dist/android/templates/CraftNativeCapabilities.kt.template

@@ -22,6 +22,7 @@ import android.net.NetworkCapabilities
 import android.provider.MediaStore
 import android.util.Base64
 import androidx.core.content.ContextCompat
+import androidx.core.app.ActivityCompat
 import androidx.biometric.BiometricManager
 import androidx.biometric.BiometricPrompt
 import androidx.fragment.app.FragmentActivity
@@ -50,6 +51,7 @@ private const val CRAFT_NATIVE_FILE_PICK_FIRST = 0x4000
 private const val CRAFT_NATIVE_FILE_PICK_LAST = 0xffff
 private const val CRAFT_NATIVE_FILE_PICK_STATE = "craft.filePicker.nextCode"
 private const val CRAFT_NATIVE_NOTIFICATION_PERMISSION_REQUEST = 4102
+private const val CRAFT_NATIVE_PEDOMETER_PERMISSION_REQUEST = 4358
 private const val CRAFT_NATIVE_FILE_DEFAULT_MAX_PIXELS = 2048
 private const val CRAFT_NATIVE_FILE_LARGEST_MAX_PIXELS = 8192
 private const val CRAFT_NATIVE_FILE_DEFAULT_QUALITY = 0.85
@@ -88,6 +90,8 @@ internal class CraftNativeCapabilities(
             override fun dismiss(requestCode: Int) { host.finishActivity(requestCode) }
         }
     },
+    private val requestPedometerPermission: ((Int) -> Unit)? = null,
+    private val checkPedometerPermission: (() -> Boolean)? = null,
 ) {
     companion object {
         private val pickerCodes = CraftNativePickerCodes()
@@ -127,6 +131,8 @@ internal class CraftNativeCapabilities(
     private val fileRoot by lazy { File(context.cacheDir, "craft-files").apply { mkdirs() } }
     private var pendingFilePick: PendingFilePick? = null
     private var pendingNotificationPermission: ((Boolean) -> Unit)? = null
+    private var pendingPedometerPermission: Pair<String, (CraftNativeCapabilityResult) -> Unit>? = null
+    private var pedometerPermissionInFlight = false
     private var database: SQLiteDatabase? = null
     private val biometricPrompts = ConcurrentHashMap<String, BiometricPrompt>()
 
@@ -214,6 +220,29 @@ internal class CraftNativeCapabilities(
                 if (method == "randomUUID") complete(requestToken, success(UUID.randomUUID().toString()), completion)
                 else complete(requestToken, failure("UNKNOWN_ACTION", "Unsupported Crypto method"), completion)
             }
+            "Pedometer" -> {
+                if (!config.optBoolean("enablePedometer")) complete(requestToken, failure("CAPABILITY_DISABLED", "Pedometer is disabled"), completion)
+                else if (method != "requestPermission") complete(requestToken, failure("UNKNOWN_ACTION", "Unsupported Pedometer permission method"), completion)
+                else onMain {
+                    if (cancelled.remove(requestToken) || closed.get()) return@onMain
+                    val host = activity
+                    if (host == null && requestPedometerPermission == null) complete(requestToken, failure("NEEDS_ACTIVITY", "Pedometer permission needs a screen"), completion)
+                    else if (pedometerPermissionGranted()) complete(requestToken, success("granted"), completion)
+                    else if (pedometerPermissionInFlight) complete(requestToken, failure("PERMISSION_BUSY", "An activity recognition request is already open"), completion)
+                    else {
+                        pendingPedometerPermission = requestToken to completion
+                        pedometerPermissionInFlight = true
+                        try {
+                            if (requestPedometerPermission != null) requestPedometerPermission.invoke(CRAFT_NATIVE_PEDOMETER_PERMISSION_REQUEST)
+                            else ActivityCompat.requestPermissions(requireNotNull(host), arrayOf(Manifest.permission.ACTIVITY_RECOGNITION), CRAFT_NATIVE_PEDOMETER_PERMISSION_REQUEST)
+                        } catch (error: Exception) {
+                            pendingPedometerPermission = null
+                            pedometerPermissionInFlight = false
+                            complete(requestToken, failure("PERMISSION_ERROR", error.message ?: "Permission could not be requested"), completion)
+                        }
+                    }
+                }
+            }
             "Bluetooth" -> {
                 if (!config.optBoolean("enableBluetooth")) complete(requestToken, failure("CAPABILITY_DISABLED", "Bluetooth is disabled"), completion)
                 else bluetooth.perform(method, args) { complete(requestToken, it, completion) }
@@ -268,6 +297,7 @@ internal class CraftNativeCapabilities(
         cancelled.add(requestToken)
         fetchConnections.remove(requestToken)?.disconnect()
         onMain {
+            if (pendingPedometerPermission?.first == requestToken) pendingPedometerPermission = null
             if (pendingFilePick?.requestToken == requestToken) {
                 dismissFilePick()
                 cancelled.remove(requestToken)
@@ -285,13 +315,24 @@ internal class CraftNativeCapabilities(
         networkExecutor.shutdownNow()
         fetchConnections.values.forEach(HttpURLConnection::disconnect)
         fetchConnections.clear()
-        onMain { dismissFilePick() }
+        onMain { dismissFilePick(); pendingPedometerPermission = null; pedometerPermissionInFlight = false }
         database?.close()
         database = null
         biometricPrompts.values.forEach { it.cancelAuthentication() }
         biometricPrompts.clear()
     }
 
+    fun pedometerPermissionGranted(): Boolean = checkPedometerPermission?.invoke() ?: (Build.VERSION.SDK_INT < 29 ||
+        ContextCompat.checkSelfPermission(context, Manifest.permission.ACTIVITY_RECOGNITION) == PackageManager.PERMISSION_GRANTED)
+
+    fun onPedometerPermissions(requestCode: Int) {
+        if (requestCode != CRAFT_NATIVE_PEDOMETER_PERMISSION_REQUEST) return
+        pedometerPermissionInFlight = false
+        val pending = pendingPedometerPermission
+        pendingPedometerPermission = null
+        pending?.let { (token, completion) -> complete(token, success(if (pedometerPermissionGranted()) "granted" else "denied"), completion) }
+    }
+
     private fun onMain(work: () -> Unit) {
         if (android.os.Looper.myLooper() == android.os.Looper.getMainLooper()) work()
         else mainHandler.post { work() }

package/dist/android/templates/CraftNativeMotion.kt.template

@@ -0,0 +1,269 @@
+package {{PACKAGE_NAME}}
+
+import android.content.Context
+import android.hardware.Sensor
+import android.hardware.SensorEvent
+import android.hardware.SensorEventListener
+import android.hardware.SensorManager
+import android.os.Handler
+import android.os.Looper
+import org.json.JSONArray
+import org.json.JSONObject
+
+/** Registration owns its listener. Closing an old registration cannot stop a replacement. */
+internal interface CraftMotionRegistration { fun close() }
+internal interface CraftMotionSource {
+    fun available(type: Int): Boolean
+    fun register(type: Int, periodUs: Int, sample: (FloatArray, Long, Int) -> Unit): CraftMotionRegistration?
+}
+
+internal class CraftAndroidMotionSource(context: Context) : CraftMotionSource {
+    private val manager = context.getSystemService(Context.SENSOR_SERVICE) as? SensorManager
+    override fun available(type: Int): Boolean = manager?.getDefaultSensor(type) != null
+    override fun register(type: Int, periodUs: Int, sample: (FloatArray, Long, Int) -> Unit): CraftMotionRegistration? {
+        val manager = manager ?: return null
+        val sensor = manager.getDefaultSensor(type) ?: return null
+        val listener = object : SensorEventListener {
+            override fun onSensorChanged(event: SensorEvent) {
+                sample(event.values.clone(), event.timestamp, event.accuracy)
+            }
+            override fun onAccuracyChanged(sensor: Sensor?, accuracy: Int) {}
+        }
+        try {
+            if (!manager.registerListener(listener, sensor, periodUs, Handler(Looper.getMainLooper()))) {
+                manager.unregisterListener(listener)
+                return null
+            }
+        } catch (error: Exception) {
+            manager.unregisterListener(listener)
+            throw error
+        }
+        return object : CraftMotionRegistration {
+            override fun close() { manager.unregisterListener(listener) }
+        }
+    }
+}
+
+/** Foreground, route-owned raw readings; deliberately distinct from iOS CMDeviceMotion. */
+internal class CraftNativeMotion(private val source: CraftMotionSource) {
+    private data class Kind(val type: Int, val unit: String)
+    private val kinds = linkedMapOf(
+        "accelerometer" to Kind(Sensor.TYPE_ACCELEROMETER, "m/s²"),
+        "gyroscope" to Kind(Sensor.TYPE_GYROSCOPE, "rad/s"),
+        "magnetometer" to Kind(Sensor.TYPE_MAGNETIC_FIELD, "µT"),
+        "rotationVector" to Kind(Sensor.TYPE_ROTATION_VECTOR, "quaternion"),
+    )
+    private class Stream { var registration: CraftMotionRegistration? = null }
+    private val streams = mutableMapOf<String, Stream>()
+    private var closed = false
+    var emit: (JSONObject) -> Unit = {}
+
+    fun perform(method: String, args: JSONArray): CraftNativeCapabilityResult {
+        if (closed) return failure("HOST_CLOSED", "Motion host is closed")
+        return when (method) {
+            "getAvailability" -> CraftNativeCapabilityResult(data = JSONObject().apply {
+                kinds.forEach { (name, kind) -> put(name, source.available(kind.type)) }
+            })
+            "start" -> start(args.optJSONObject(0))
+            "stop" -> {
+                val name = args.opt(0) as? String
+                if (name !in kinds) failure("INVALID_ARGUMENT", "Unknown motion sensor")
+                else CraftNativeCapabilityResult(data = stop(name!!))
+            }
+            "stopAll" -> { stopAll(); CraftNativeCapabilityResult(data = true) }
+            else -> failure("UNKNOWN_ACTION", "Unsupported MotionSensors method")
+        }
+    }
+
+    private fun start(options: JSONObject?): CraftNativeCapabilityResult {
+        val name = options?.opt("sensor") as? String
+        val kind = kinds[name] ?: return failure("INVALID_ARGUMENT", "Unknown motion sensor")
+        val rawInterval = if (options?.has("intervalMs") == true) options.opt("intervalMs") else 100
+        val interval = (rawInterval as? Number)?.toDouble() ?: Double.NaN
+        // Do not silently opt an app into Android's high sampling-rate permission.
+        if (!interval.isFinite() || interval < 5 || interval > 60_000 || interval % 1 != 0.0) {
+            return failure("INVALID_ARGUMENT", "intervalMs must be an integer from 5 through 60000")
+        }
+        if (!source.available(kind.type)) return failure("UNAVAILABLE", "Sensor is not present: $name")
+        val stream = Stream()
+        val registration = try {
+            source.register(kind.type, (interval * 1000).toInt()) { values, timestamp, accuracy ->
+                // Android can still deliver a queued sample after unregisterListener.
+                if (!closed && streams[name] === stream && values.size >= 3) {
+                    val reading = if (kind.type == Sensor.TYPE_ROTATION_VECTOR) {
+                        val quaternion = FloatArray(4)
+                        SensorManager.getQuaternionFromVector(quaternion, values)
+                        JSONObject().put("w", quaternion[0]).put("x", quaternion[1])
+                            .put("y", quaternion[2]).put("z", quaternion[3])
+                    } else JSONObject().put("x", values[0]).put("y", values[1]).put("z", values[2])
+                    emit(JSONObject().put("sensor", name).put("values", reading).put("unit", kind.unit)
+                        .put("timestampMs", timestamp / 1_000_000.0).put("accuracy", accuracy))
+                }
+            }
+        } catch (error: Exception) {
+            return failure("SENSOR_ERROR", error.message ?: "Sensor registration failed")
+        } ?: return failure("UNAVAILABLE", "Sensor registration was rejected: $name")
+        stream.registration = registration
+        // Validate and acquire the replacement before retiring a working stream.
+        val previous = streams.put(name!!, stream)
+        previous?.registration?.close()
+        return CraftNativeCapabilityResult(data = true)
+    }
+
+    private fun failure(code: String, message: String) = CraftNativeCapabilityResult(code = code, message = message)
+    private fun stop(name: String): Boolean {
+        val stream = streams.remove(name) ?: return false
+        stream.registration?.close()
+        return true
+    }
+    fun stopAll() { streams.keys.toList().forEach(::stop) }
+    fun close() { closed = true; stopAll(); emit = {} }
+}
+
+/** A pressure-only stream with a new reference on each successful start. */
+internal class CraftNativeBarometer(private val source: CraftMotionSource) {
+    private class Stream {
+        var registration: CraftMotionRegistration? = null
+        var reference: Float? = null
+    }
+    private var stream: Stream? = null
+    private var closed = false
+    var emit: (JSONObject) -> Unit = {}
+
+    fun perform(method: String, args: JSONArray): CraftNativeCapabilityResult {
+        if (closed) return failure("HOST_CLOSED", "Barometer host is closed")
+        return when (method) {
+            "getAvailability" -> CraftNativeCapabilityResult(data = JSONObject()
+                .put("relativeAltitude", source.available(Sensor.TYPE_PRESSURE))
+                .put("absoluteAltitude", false).put("background", false))
+            "start" -> start(args.optJSONObject(0), args.length() != 0)
+            "stop" -> CraftNativeCapabilityResult(data = stop("requested"))
+            else -> failure("UNKNOWN_ACTION", "Unsupported Barometer method")
+        }
+    }
+
+    private fun start(options: JSONObject?, supplied: Boolean): CraftNativeCapabilityResult {
+        if (supplied && options == null) return failure("INVALID_ARGUMENT", "Barometer.start needs an options object")
+        if (options?.has("background") == true && options.opt("background") !is Boolean)
+            return failure("INVALID_ARGUMENT", "background must be boolean")
+        if (options?.optBoolean("background", false) == true)
+            return failure("UNSUPPORTED", "Background barometer recording is not supported")
+        val raw = if (options?.has("intervalMs") == true) options.opt("intervalMs") else 100
+        val interval = (raw as? Number)?.toDouble() ?: Double.NaN
+        if (!interval.isFinite() || interval < 5 || interval > 60_000 || interval % 1 != 0.0)
+            return failure("INVALID_ARGUMENT", "intervalMs must be an integer from 5 through 60000")
+        if (!source.available(Sensor.TYPE_PRESSURE)) return failure("UNAVAILABLE", "Barometer is not present")
+        val next = Stream()
+        val registration = try {
+            source.register(Sensor.TYPE_PRESSURE, (interval * 1000).toInt()) { values, timestamp, _ ->
+                if (!closed && stream === next) {
+                    val pressure = values.firstOrNull()
+                    if (pressure == null || !pressure.isFinite() || pressure <= 0) {
+                        stop("sensorError")
+                    } else {
+                        val reference = next.reference ?: pressure.also { next.reference = it }
+                        val altitude = SensorManager.getAltitude(reference, pressure)
+                        if (!altitude.isFinite()) stop("sensorError")
+                        else emit(JSONObject().put("state", "sample").put("pressureHpa", pressure)
+                            .put("relativeAltitudeMeters", altitude).put("referencePressureHpa", reference)
+                            .put("timestampMs", timestamp / 1_000_000.0))
+                    }
+                }
+            }
+        } catch (error: Exception) {
+            return failure("SENSOR_ERROR", error.message ?: "Barometer registration failed")
+        } ?: return failure("UNAVAILABLE", "Barometer registration was rejected")
+        next.registration = registration
+        val previous = stream
+        stream = next
+        previous?.registration?.close()
+        return CraftNativeCapabilityResult(data = true)
+    }
+
+    fun stop(reason: String): Boolean {
+        val previous = stream ?: return false
+        stream = null
+        previous.registration?.close()
+        emit(JSONObject().put("state", "stopped").put("reason", reason))
+        return true
+    }
+    fun close() { closed = true; stop("disposed"); emit = {} }
+    private fun failure(code: String, message: String) = CraftNativeCapabilityResult(code = code, message = message)
+}
+
+/** Android counter and detector semantics stay distinct from interval totals. */
+internal class CraftNativePedometer(private val source: CraftMotionSource, private val hasPermission: () -> Boolean) {
+    private class Stream { var registration: CraftMotionRegistration? = null }
+    private var stream: Stream? = null
+    private var closed = false
+    var emit: (JSONObject) -> Unit = {}
+
+    fun perform(method: String, args: JSONArray): CraftNativeCapabilityResult {
+        if (closed) return failure("HOST_CLOSED", "Pedometer host is closed")
+        return when (method) {
+            "getAvailability" -> CraftNativeCapabilityResult(data = JSONObject()
+                .put("counter", source.available(Sensor.TYPE_STEP_COUNTER))
+                .put("detector", source.available(Sensor.TYPE_STEP_DETECTOR))
+                .put("history", false).put("background", false).put("cadence", false).put("floors", false))
+            "getPermissionStatus" -> CraftNativeCapabilityResult(data = if (hasPermission()) "granted" else "denied")
+            "start" -> start(args.optJSONObject(0), args.length() != 0)
+            "stop" -> CraftNativeCapabilityResult(data = stop("requested"))
+            "query" -> failure("UNSUPPORTED", "Android's step sensor does not provide interval history")
+            else -> failure("UNKNOWN_ACTION", "Unsupported Pedometer method")
+        }
+    }
+
+    private fun start(options: JSONObject?, supplied: Boolean): CraftNativeCapabilityResult {
+        if (supplied && options == null) return failure("INVALID_ARGUMENT", "Pedometer.start needs an options object")
+        if (options?.has("background") == true && options.opt("background") !is Boolean)
+            return failure("INVALID_ARGUMENT", "background must be boolean")
+        if (options?.optBoolean("background", false) == true)
+            return failure("UNSUPPORTED", "Background step streaming is not supported by this sensor adapter")
+        val name = if (options?.has("sensor") == true) options.opt("sensor") as? String else "counter"
+        val type = when (name) {
+            "counter" -> Sensor.TYPE_STEP_COUNTER
+            "detector" -> Sensor.TYPE_STEP_DETECTOR
+            else -> return failure("INVALID_ARGUMENT", "sensor must be counter or detector")
+        }
+        if (options?.has("startDate") == true || options?.has("endDate") == true)
+            return failure("UNSUPPORTED", "Android steps are not counts for a requested interval")
+        if (!source.available(type)) return failure("UNAVAILABLE", "Requested step sensor is not present")
+        if (!hasPermission()) return failure("PERMISSION_DENIED", "Activity recognition permission is required")
+        val next = Stream()
+        val registration = try {
+            source.register(type, 200_000) { values, timestamp, _ ->
+                if (!closed && stream === next) {
+                    val value = values.firstOrNull()
+                    if (!hasPermission()) stop("permissionDenied")
+                    else if (value == null || !value.isFinite() || value < 0 || value % 1f != 0f || (name == "detector" && value != 1f)) stop("sensorError")
+                    else {
+                        val payload = JSONObject().put("state", "sample").put("kind", if (name == "counter") "counter" else "step")
+                            .put("timestampMs", timestamp / 1_000_000.0)
+                        if (name == "counter") payload.put("stepsSinceBoot", value.toDouble())
+                        else payload.put("count", 1)
+                        emit(payload)
+                    }
+                }
+            }
+        } catch (error: SecurityException) {
+            return failure("PERMISSION_DENIED", "Activity recognition permission is required")
+        } catch (error: Exception) {
+            return failure("SENSOR_ERROR", error.message ?: "Step sensor registration failed")
+        } ?: return failure("UNAVAILABLE", "Step sensor registration was rejected")
+        next.registration = registration
+        val previous = stream
+        stream = next
+        previous?.registration?.close()
+        return CraftNativeCapabilityResult(data = true)
+    }
+
+    fun stop(reason: String): Boolean {
+        val previous = stream ?: return false
+        stream = null
+        previous.registration?.close()
+        emit(JSONObject().put("state", "stopped").put("reason", reason))
+        return true
+    }
+    fun close() { closed = true; stop("disposed"); emit = {} }
+    private fun failure(code: String, message: String) = CraftNativeCapabilityResult(code = code, message = message)
+}

package/dist/android/templates/CraftNativeServices.kt.template

@@ -129,10 +129,12 @@ internal class CraftNativeServices(
             add("healthAvailability")
         }
         if (healthServices != null) add("healthServices")
+        if (healthServices != null && config.optBoolean("enablePedometer")) add("pedometerPassive")
         if (config.optBoolean("enableWallet")) add("wallet")
         if (config.optBoolean("enableKeepAwake")) add("keepAwake")
         if (config.optBoolean("enableGeolocation") || config.optBoolean("enableBackgroundLocation")) {
             add("geolocation")
+            if (config.optBoolean("enableBarometer") && config.optBoolean("enableBackgroundLocation")) add("locationRecordingBarometer")
             if (CraftNative.supportsRecordingOwnership()) add("locationRecordingOwnership")
             if (CraftNative.supportsRecordingIntentIdentity()) add("locationRecordingIntentIdentity")
             if (CraftNative.supportsRecordingPowerMode()) add("locationRecordingPowerMode")
@@ -146,7 +148,7 @@ internal class CraftNativeServices(
     }
 
     fun handles(module: String): Boolean = module in setOf(
-        "Dialog", "Browser", "Linking", "Share", "Push", "Health", "KeepAwake", "Brightness", "StatusBar", "Speech", "Background",
+        "Dialog", "Browser", "Linking", "Share", "Push", "Health", "PedometerPassive", "KeepAwake", "Brightness", "StatusBar", "Speech", "Background",
         "Location", "Media", "CrashReporter", "HeartRate", "AudioRecording",
         "Wallet",
     )
@@ -165,6 +167,9 @@ internal class CraftNativeServices(
                 "Health" -> if (healthServices != null && method in setOf("startWorkout", "pauseWorkout", "resumeWorkout", "endWorkout")) {
                     healthServices.perform(method, args, done)
                 } else health?.perform(method, args, done) ?: done(failure("CAPABILITY_DISABLED", "Health is not enabled for this app"))
+                "PedometerPassive" -> if (config.optBoolean("enablePedometer") && healthServices != null) {
+                    healthServices.perform("passive:$method", args, done)
+                } else done(failure("CAPABILITY_DISABLED", "Passive steps require pedometer and Health Services"))
                 "Wallet" -> wallet(method, args, done)
                 "KeepAwake" -> keepAwake(args.optBoolean(0, true), done)
                 "Brightness" -> brightness(method, args, done)