craft-native 0.0.236 → 0.0.238

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

@@ -600,19 +600,43 @@ private class CraftNativeSvgView(context: Context) : View(context) {
 /** The Android host for the small, host-neutral native trail map contract. */
 private class CraftNativeMapView(context: Context) : FrameLayout(context), OnMapReadyCallback {
     private val mapView = MapView(context)
+    private val scaleView = LinearLayout(context).apply {
+        orientation = LinearLayout.VERTICAL
+        setPadding(4, 2, 4, 2)
+        background = GradientDrawable().apply { setColor(Color.argb(230, 255, 255, 255)); cornerRadius = 4f }
+        importantForAccessibility = View.IMPORTANT_FOR_ACCESSIBILITY_NO
+    }
+    private val scaleLabel = TextView(context).apply { textSize = 11f; setTextColor(Color.rgb(37, 51, 33)) }
+    private val scaleLine = View(context).apply { setBackgroundColor(Color.rgb(37, 51, 33)) }
     private var googleMap: GoogleMap? = null
+    private var tileOverlay: com.google.android.gms.maps.model.TileOverlay? = null
+    private var tileTemplate: String? = null
+    private val tileAttribution = TextView(context).apply { textSize = 9f; setTextColor(Color.DKGRAY); setBackgroundColor(Color.argb(220, 255, 255, 255)); maxLines = 2; visibility = View.GONE }
     private var pendingProps = JSONObject()
     private var pendingChildren = JSONArray()
     private val markers = mutableMapOf<String, Marker>()
     private val polylines = mutableMapOf<String, Polyline>()
     private val markerHandlers = mutableMapOf<String, String>()
     private var onMarkerTap: ((String) -> Unit)? = null
+    var onMapPress: ((LatLng) -> Unit)? = null
+    var onRegionChangeComplete: ((JSONObject) -> Unit)? = null
+    private var userChangingCamera = false
+    private var markerBearings = mutableMapOf<String, Float>()
+    private var directionIcon: com.google.android.gms.maps.model.BitmapDescriptor? = null
     private var lifecycleStarted = false
     private var destroyed = false
     private var initialCameraKey: String? = null
 
     init {
         addView(mapView, LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT))
+        scaleView.addView(scaleLabel)
+        scaleView.addView(scaleLine, LinearLayout.LayoutParams(1, 2))
+        addView(scaleView, LayoutParams(LayoutParams.WRAP_CONTENT, LayoutParams.WRAP_CONTENT, Gravity.BOTTOM or Gravity.START).apply {
+            leftMargin = (8 * resources.displayMetrics.density).roundToInt()
+            bottomMargin = (24 * resources.displayMetrics.density).roundToInt()
+        })
+        scaleView.visibility = View.GONE
+        addView(tileAttribution, LayoutParams(LayoutParams.WRAP_CONTENT, LayoutParams.WRAP_CONTENT, Gravity.BOTTOM or Gravity.END).apply { rightMargin = (8 * resources.displayMetrics.density).roundToInt(); bottomMargin = (8 * resources.displayMetrics.density).roundToInt() })
         mapView.onCreate(null)
         mapView.getMapAsync(this)
     }
@@ -620,6 +644,24 @@ private class CraftNativeMapView(context: Context) : FrameLayout(context), OnMap
     override fun onMapReady(map: GoogleMap) {
         if (destroyed) return
         googleMap = map
+        map.setOnMapClickListener { point -> onMapPress?.invoke(point) }
+        map.setOnCameraMoveStartedListener { reason ->
+            if (reason == GoogleMap.OnCameraMoveStartedListener.REASON_GESTURE) userChangingCamera = true
+        }
+        map.setOnCameraMoveListener { updateScale() }
+        map.setOnCameraIdleListener {
+            updateScale()
+            if (userChangingCamera) {
+                userChangingCamera = false
+                val bounds = map.projection.visibleRegion.latLngBounds
+                val position = map.cameraPosition
+                val longitudeDelta = (bounds.northeast.longitude - bounds.southwest.longitude + 360) % 360
+                onRegionChangeComplete?.invoke(JSONObject()
+                    .put("center", JSONObject().put("latitude", position.target.latitude).put("longitude", position.target.longitude))
+                    .put("span", JSONObject().put("latitudeDelta", bounds.northeast.latitude - bounds.southwest.latitude).put("longitudeDelta", longitudeDelta))
+                    .put("heading", position.bearing).put("pitch", position.tilt))
+            }
+        }
         map.setOnMarkerClickListener { marker ->
             val id = markers.entries.firstOrNull { it.value == marker }?.key ?: return@setOnMarkerClickListener false
             onMarkerTap?.invoke(id)
@@ -642,6 +684,10 @@ private class CraftNativeMapView(context: Context) : FrameLayout(context), OnMap
 
     private fun applyPending() {
         val map = googleMap ?: return
+        applyMapPadding()
+        map.uiSettings.isCompassEnabled = craftNativeBoolean(pendingProps.opt("showsCompass"))
+        // The toolbar is replaced by authored actions; the scale uses the native projection.
+        map.uiSettings.isMapToolbarEnabled = false
         map.uiSettings.isScrollGesturesEnabled = craftNativeBoolean(pendingProps.opt("scrollEnabled"), true)
         map.uiSettings.isZoomGesturesEnabled = craftNativeBoolean(pendingProps.opt("zoomEnabled"), true)
         map.uiSettings.isRotateGesturesEnabled = craftNativeBoolean(pendingProps.opt("rotateEnabled"))
@@ -651,9 +697,11 @@ private class CraftNativeMapView(context: Context) : FrameLayout(context), OnMap
             "terrain" -> GoogleMap.MAP_TYPE_TERRAIN
             else -> GoogleMap.MAP_TYPE_NORMAL
         }
+        applyTileOverlay()
         val showUserLocation = craftNativeBoolean(pendingProps.opt("showsUserLocation")) && hasLocationPermission()
         runCatching { map.isMyLocationEnabled = showUserLocation }
         val nextMarkers = mutableMapOf<String, Pair<LatLng, String?>>()
+        val nextBearings = mutableMapOf<String, Float>()
         val nextHandlers = mutableMapOf<String, String>()
         val nextPolylines = mutableMapOf<String, Triple<List<LatLng>, Int, Float>>()
         for (index in 0 until pendingChildren.length()) {
@@ -668,6 +716,7 @@ private class CraftNativeMapView(context: Context) : FrameLayout(context), OnMap
             if (type == "mapmarker" || type == "marker") {
                 points.firstOrNull()?.let { point ->
                     nextMarkers[id] = point to (props.opt("title") as? String)
+                    (props.opt("bearing") as? Number)?.toDouble()?.takeIf { it.isFinite() }?.let { nextBearings[id] = (it % 360).toFloat() }
                     listOf(events.opt("onPress"), events.opt("onMarkerPress"))
                         .firstNotNullOfOrNull(::craftNativeOptionalString)
                         ?.let { nextHandlers[id] = it }
@@ -694,14 +743,19 @@ private class CraftNativeMapView(context: Context) : FrameLayout(context), OnMap
                 }
             }
         }
+        markerBearings = nextBearings
         markers.keys.filter { nextMarkers[it] == null }.forEach { markers.remove(it)?.remove() }
         for ((id, value) in nextMarkers) {
             val marker = markers[id]
             if (marker != null) {
                 marker.position = value.first
                 marker.title = value.second
+                marker.setIcon(if (markerBearings.containsKey(id)) directionMarkerIcon() else BitmapDescriptorFactory.defaultMarker())
+                marker.isFlat = markerBearings.containsKey(id)
+                marker.rotation = markerBearings[id] ?: 0f
+                marker.setAnchor(0.5f, if (markerBearings.containsKey(id)) 0.5f else 1f)
             } else {
-                map.addMarker(MarkerOptions().position(value.first).title(value.second).icon(BitmapDescriptorFactory.defaultMarker()))?.let { markers[id] = it }
+                map.addMarker(MarkerOptions().position(value.first).title(value.second).icon(if (markerBearings.containsKey(id)) directionMarkerIcon() else BitmapDescriptorFactory.defaultMarker()).flat(markerBearings.containsKey(id)).rotation(markerBearings[id] ?: 0f).anchor(0.5f, if (markerBearings.containsKey(id)) 0.5f else 1f))?.let { markers[id] = it }
             }
         }
         markerHandlers.clear()
@@ -734,17 +788,99 @@ private class CraftNativeMapView(context: Context) : FrameLayout(context), OnMap
                 initialCameraKey = key
             }
         } else if (craftNativeBoolean(pendingProps.opt("fitToBounds"))) {
-            val key = "fit:${overlayKey(nextMarkers, nextPolylines)}"
+            val key = "fit:${overlayKey(nextMarkers, nextPolylines)}:${pendingProps.optJSONObject("edgePadding")}"
             if (initialCameraKey != key) {
                 if (fitToBounds()) initialCameraKey = key
             }
         } else {
             initialCameraKey = null
         }
+        applyCameraOrientation()
+        updateScale()
+    }
+
+    private fun applyTileOverlay() {
+        val map = googleMap ?: return
+        val options = pendingProps.optJSONObject("tileOverlay")
+        val template = options?.optString("urlTemplate").orEmpty()
+        val credit = options?.optString("attribution").orEmpty()
+        val next = template.takeIf { it.startsWith("https://") && listOf("{z}", "{x}", "{y}").all { key -> it.contains(key) } && credit.isNotBlank() }
+        if (next != tileTemplate) {
+            tileOverlay?.remove(); tileOverlay = null; tileTemplate = next
+            if (next != null) {
+                val provider = object : com.google.android.gms.maps.model.UrlTileProvider(256, 256) {
+                    override fun getTileUrl(x: Int, y: Int, zoom: Int): java.net.URL? = runCatching { java.net.URL(next.replace("{x}", x.toString()).replace("{y}", y.toString()).replace("{z}", zoom.toString())) }.getOrNull()
+                }
+                tileOverlay = map.addTileOverlay(com.google.android.gms.maps.model.TileOverlayOptions().tileProvider(provider).zIndex(-1f))
+            }
+        }
+        if (next != null) map.mapType = GoogleMap.MAP_TYPE_NONE
+        tileAttribution.text = credit
+        tileAttribution.visibility = if (next == null) View.GONE else View.VISIBLE
+    }
+
+    private fun applyMapPadding() {
+        val authored = pendingProps.optJSONObject("edgePadding")
+        fun inset(name: String): Double = (authored?.opt(name) as? Number)?.toDouble()?.takeIf { it.isFinite() }?.coerceIn(0.0, 10_000.0)?.times(resources.displayMetrics.density) ?: 0.0
+        var left = inset("left"); var top = inset("top"); var right = inset("right"); var bottom = inset("bottom")
+        val horizontal = left + right
+        val vertical = top + bottom
+        val availableWidth = (width - 40 * resources.displayMetrics.density).coerceAtLeast(0f).toDouble()
+        val availableHeight = (height - 40 * resources.displayMetrics.density).coerceAtLeast(0f).toDouble()
+        if (horizontal > availableWidth && horizontal > 0) { left *= availableWidth / horizontal; right *= availableWidth / horizontal }
+        if (vertical > availableHeight && vertical > 0) { top *= availableHeight / vertical; bottom *= availableHeight / vertical }
+        googleMap?.setPadding(left.roundToInt(), top.roundToInt(), right.roundToInt(), bottom.roundToInt())
+    }
+
+    private fun updateScale() {
+        val map = googleMap ?: return
+        if (!craftNativeBoolean(pendingProps.opt("showsScale")) || width <= 0 || height <= 0) { scaleView.visibility = View.GONE; return }
+        val maximumWidth = (80 * resources.displayMetrics.density).roundToInt()
+        val origin = map.projection.fromScreenLocation(android.graphics.Point(width / 2, height / 2))
+        val end = map.projection.fromScreenLocation(android.graphics.Point(width / 2 + maximumWidth, height / 2))
+        val distance = FloatArray(1)
+        android.location.Location.distanceBetween(origin.latitude, origin.longitude, end.latitude, end.longitude, distance)
+        val metres = distance[0].toDouble()
+        if (!metres.isFinite() || metres <= 0) { scaleView.visibility = View.GONE; return }
+        val magnitude = Math.pow(10.0, kotlin.math.floor(kotlin.math.log10(metres)))
+        val length = listOf(5.0, 2.0, 1.0).firstOrNull { it * magnitude <= metres }?.times(magnitude) ?: magnitude
+        scaleLabel.text = if (length >= 1000) "${length / 1000} km" else "${length.roundToInt()} m"
+        scaleLine.layoutParams = LinearLayout.LayoutParams((maximumWidth * length / metres).roundToInt().coerceAtLeast(1), 2)
+        scaleView.visibility = View.VISIBLE
+    }
+
+    private fun applyCameraOrientation() {
+        val map = googleMap ?: return
+        val camera = map.cameraPosition
+        val pitch = (pendingProps.opt("cameraPitch") as? Number)?.toDouble()?.takeIf { it.isFinite() }?.coerceIn(0.0, 60.0)?.toFloat() ?: camera.tilt
+        val heading = (pendingProps.opt("cameraHeading") as? Number)?.toDouble()?.takeIf { it.isFinite() }?.toFloat() ?: camera.bearing
+        if (kotlin.math.abs(camera.tilt - pitch) > 0.01f || kotlin.math.abs(camera.bearing - heading) > 0.01f) {
+            map.moveCamera(CameraUpdateFactory.newCameraPosition(com.google.android.gms.maps.model.CameraPosition.Builder(camera).tilt(pitch).bearing(heading).build()))
+        }
+    }
+
+    private fun directionMarkerIcon(): com.google.android.gms.maps.model.BitmapDescriptor {
+        directionIcon?.let { return it }
+        val size = (26 * resources.displayMetrics.density).roundToInt().coerceAtLeast(24)
+        val bitmap = Bitmap.createBitmap(size, size, Bitmap.Config.ARGB_8888)
+        val canvas = Canvas(bitmap)
+        val paint = Paint(Paint.ANTI_ALIAS_FLAG)
+        paint.color = Color.WHITE
+        canvas.drawCircle(size / 2f, size / 2f, size / 2f, paint)
+        paint.color = Color.rgb(36, 114, 75)
+        canvas.drawCircle(size / 2f, size / 2f, size * 0.43f, paint)
+        paint.color = Color.WHITE
+        paint.textSize = size * 0.76f
+        paint.textAlign = Paint.Align.CENTER
+        paint.typeface = Typeface.DEFAULT_BOLD
+        canvas.drawText("↑", size / 2f, size / 2f - (paint.ascent() + paint.descent()) / 2, paint)
+        return BitmapDescriptorFactory.fromBitmap(bitmap).also { directionIcon = it }
     }
 
     override fun onSizeChanged(width: Int, height: Int, oldWidth: Int, oldHeight: Int) {
         super.onSizeChanged(width, height, oldWidth, oldHeight)
+        applyMapPadding()
+        updateScale()
         // MapView can become ready before its host has a usable viewport. Do
         // not mark a fit as complete until the camera update can be issued.
         if (width > 0 && height > 0 && craftNativeBoolean(pendingProps.opt("fitToBounds")) && initialCameraKey == null) {
@@ -754,7 +890,10 @@ private class CraftNativeMapView(context: Context) : FrameLayout(context), OnMap
 
     private fun moveCamera(bounds: LatLngBounds, padding: Int = 24) {
         post {
-            if (width > 0 && height > 0) googleMap?.moveCamera(CameraUpdateFactory.newLatLngBounds(bounds, padding))
+            if (width > 0 && height > 0) {
+                googleMap?.moveCamera(CameraUpdateFactory.newLatLngBounds(bounds, padding))
+                applyCameraOrientation()
+            }
         }
     }
 
@@ -780,7 +919,12 @@ private class CraftNativeMapView(context: Context) : FrameLayout(context), OnMap
         polylines.values.flatMap { it.points }.forEach { builder.include(it); count++ }
         if (count == 0) return false
         post {
-            if (width > 0 && height > 0) map.moveCamera(CameraUpdateFactory.newLatLngBounds(builder.build(), 24))
+            if (width > 0 && height > 0) {
+                applyMapPadding()
+                val padding = if (pendingProps.has("edgePadding")) 0 else (24 * resources.displayMetrics.density).roundToInt()
+                map.moveCamera(CameraUpdateFactory.newLatLngBounds(builder.build(), padding))
+                applyCameraOrientation()
+            }
         }
         return true
     }
@@ -811,6 +955,10 @@ private class CraftNativeMapView(context: Context) : FrameLayout(context), OnMap
             lifecycleStarted = false
         }
         onMarkerTap = null
+        onMapPress = null
+        onRegionChangeComplete = null
+        directionIcon = null
+        tileOverlay?.remove(); tileOverlay = null
         markerHandlers.clear()
         markers.values.forEach { it.remove() }
         markers.clear()
@@ -5746,6 +5894,16 @@ class MainActivity : AppCompatActivity() {
             }
             "Map" -> (previous as? CraftNativeMapView ?: CraftNativeMapView(this)).apply {
                 val mapMarkerHandler = craftNativeOptionalString(events.opt("onMarkerPress"))
+                onMapPress = { point ->
+                    craftNativeOptionalString(events.opt("onPress"))?.let { handler ->
+                        send(screen, "EVENT", JSONObject().put("handlerName", handler).put("nativeEvent", JSONObject().put("latitude", point.latitude).put("longitude", point.longitude)))
+                    }
+                }
+                onRegionChangeComplete = { region ->
+                    craftNativeOptionalString(events.opt("onRegionChangeComplete"))?.let { handler ->
+                        send(screen, "EVENT", JSONObject().put("handlerName", handler).put("nativeEvent", region))
+                    }
+                }
                 configure(props, children) { markerId ->
                     (markerHandler(markerId) ?: mapMarkerHandler)?.let { handler ->
                         send(screen, "EVENT", JSONObject().put("handlerName", handler).put("nativeEvent", JSONObject().put("id", markerId)))
@@ -7153,7 +7311,7 @@ class MainActivity : AppCompatActivity() {
 
     override fun onRequestPermissionsResult(requestCode: Int, permissions: Array<out String>, grantResults: IntArray) {
         super.onRequestPermissionsResult(requestCode, permissions, grantResults)
-        if (::capabilities.isInitialized) capabilities.onBluetoothPermissions(requestCode)
+        if (::capabilities.isInitialized) { capabilities.onBluetoothPermissions(requestCode); capabilities.onNotificationPermissions(requestCode) }
         if (::services.isInitialized) services.onRequestPermissionsResult(requestCode)
     }
 

package/dist/android-adb.d.ts

@@ -0,0 +1,2 @@
+/** Restart adbd once and require a rooted, explicitly selected disposable emulator. */
+export declare function requireAndroidEmulatorRoot(adb: string, serial: string, timeoutMs?: number): Promise<void>;

package/dist/api/index.d.ts

@@ -17,7 +17,7 @@ export type { HttpClientOptions, RequestOptions, HttpResponse, WebSocketOptions
 export { crypto, uuid, randomString, hmac, timingSafeEqual, hashPassword, verifyPassword } from './crypto.js';
 export { env, getPlatform, isDesktop, isMobile, isCraft, getSystemInfo, exec, spawn, ChildProcess, cwd, homeDir, tempDir, exit, argv, open } from './process.js';
 export type { Platform, SystemInfo, ExecOptions, ExecResult, SpawnOptions } from './process.js';
-export { device, haptics, permissions, camera, biometrics, secureStorage, location, share, lifecycle, notifications, notifications as notification } from './mobile.js';
+export { device, haptics, permissions, camera, biometrics, secureStorage, storage, location, share, lifecycle, notifications, notifications as notification } from './mobile.js';
 export type { DeviceInfo, DeviceCapabilities, HapticStyle, HapticNotificationType, PermissionType, PermissionStatus, CameraOptions as MobileCameraOptions, PhotoResult, BiometricType, Location, LocationOptions, ShareOptions, AppState, NotificationOptions as MobileNotificationOptions } from './mobile.js';
 export { carplay, appClips, liveActivities, sharePlay, storeKit, appIntents, tipKit, focusFilters } from './ios-advanced.js';
 export type { CarPlayTemplateType, CarPlayListItem, CarPlayGridItem, CarPlayTemplate, AppClipInvocation, LiveActivityContentState, LiveActivityAttributes, LiveActivityConfig, LiveActivityHandle, SharePlaySessionState, SharePlayParticipant, SharePlayActivity, ProductType, Product, Transaction, IntentParameterType, IntentParameter, AppIntent, TipDisplayFrequency, Tip, FocusStatus, FocusFilter } from './ios-advanced.js';

package/dist/api/mobile.d.ts

@@ -459,6 +459,8 @@ export declare const secureStorage: {
  * Location coordinates.
  */
 export interface Location {
+    /** Owner captured when a native recording emits this sample. */
+    recordingId?: string;
     latitude: number;
     longitude: number;
     altitude?: number;
@@ -478,6 +480,30 @@ export interface LocationOptions {
     /** Maximum age of cached position in milliseconds */
     maximumAge?: number;
 }
+/** Persist this ID with the owning intent before starting a native recording. */
+export interface RecordingStartOptions {
+    recordingId?: string;
+}
+/** Fence a recording operation to the ID returned by start or explicit recovery. */
+export interface RecordingOwnershipOptions {
+    expectedId: string;
+}
+/** Secure IDs supplied by the platform, including WebView-free mobile hosts. */
+export declare const crypto: {
+    randomUUID(): Promise<string>;
+};
+/** Native storage, including an existing-key atomic checkpoint. */
+export declare const storage: {
+    supportsSetIfAbsent(): boolean;
+    supportsCompareAndSet(): boolean;
+    get<T = unknown>(key: string): Promise<T | null>;
+    set(key: string, value: unknown): Promise<boolean>;
+    remove(key: string): Promise<boolean>;
+    clear(): Promise<boolean>;
+    keys(): Promise<string[]>;
+    setIfAbsent(key: string, value: unknown): Promise<boolean>;
+    compareAndSet(key: string, expectedValue: unknown, nextValue: unknown): Promise<boolean>;
+};
 export interface LocationRecordingState {
     id: string | null;
     active: boolean;
@@ -507,6 +533,8 @@ export interface LocationRecordingResult extends LocationRecordingState {
  * ```
  */
 export declare const location: {
+    supportsRecordingOwnership: () => boolean;
+    supportsRecordingIntentIdentity: () => boolean;
     /**
      * Get current position.
      *
@@ -528,12 +556,13 @@ export declare const location: {
      * @param watchId - Watch ID returned from watchPosition
      */
     clearWatch(watchId: number): void;
-    startRecording(options?: LocationOptions): Promise<LocationRecordingState>;
-    pauseRecording(): Promise<LocationRecordingState>;
-    resumeRecording(): Promise<LocationRecordingState>;
-    stopRecording(): Promise<LocationRecordingResult>;
-    getRecordingState(): Promise<LocationRecordingState>;
-    readRecording(): Promise<Location[]>;
+    startRecording(options?: LocationOptions & RecordingStartOptions): Promise<LocationRecordingState>;
+    pauseRecording(options?: RecordingOwnershipOptions): Promise<LocationRecordingState>;
+    resumeRecording(options?: RecordingOwnershipOptions): Promise<LocationRecordingState>;
+    stopRecording(options?: RecordingOwnershipOptions): Promise<LocationRecordingResult>;
+    getRecordingState(options?: RecordingOwnershipOptions): Promise<LocationRecordingState>;
+    acknowledgeRecording(options: RecordingOwnershipOptions): Promise<boolean>;
+    readRecording(options?: RecordingOwnershipOptions): Promise<Location[]>;
 };
 /**
  * Share options.
@@ -914,7 +943,7 @@ export interface HeartRateSample {
     /** Milliseconds between beats, when the strap sent them. */
     rr?: number[];
 }
-export type HeartRateMethod = 'getState' | 'requestAuthorization' | 'scan' | 'stopScan' | 'getDevices' | 'connect' | 'reconnect' | 'disconnect' | 'startRecording' | 'pauseRecording' | 'resumeRecording' | 'stopRecording' | 'getRecordingState' | 'readRecording';
+export type HeartRateMethod = 'getState' | 'requestAuthorization' | 'scan' | 'stopScan' | 'getDevices' | 'connect' | 'reconnect' | 'disconnect' | 'startRecording' | 'pauseRecording' | 'resumeRecording' | 'stopRecording' | 'getRecordingState' | 'readRecording' | 'acknowledgeRecording';
 export declare function normalizeHeartRateDevice(value: unknown): HeartRateDevice | null;
 /** A state from native, made safe to render whatever an older or newer build sent. */
 export declare function normalizeHeartRateState(value: unknown): HeartRateState;
@@ -923,6 +952,8 @@ export declare function normalizeHeartRateReading(value: unknown): HeartRateRead
 /** A recording's samples, oldest first, one per timestamp, implausible ones left out. */
 export declare function normalizeHeartRateSamples(value: unknown): HeartRateSample[];
 export declare const heartRate: {
+    supportsRecordingOwnership: () => boolean;
+    supportsRecordingIntentIdentity: () => boolean;
     /** Whether this app can read a heart-rate strap. */
     isAvailable(): boolean;
     /** Whether this app build answers `method`; an older build may lack one. */
@@ -955,18 +986,20 @@ export declare const heartRate: {
         forget?: boolean;
     }) => Promise<HeartRateState>;
     /** Keep every reading natively from now on: screen locked, page suspended or app closed. */
-    startRecording: () => Promise<HeartRateRecordingState>;
-    pauseRecording: () => Promise<HeartRateRecordingState>;
-    resumeRecording: () => Promise<HeartRateRecordingState>;
+    startRecording(options?: RecordingStartOptions): Promise<HeartRateRecordingState>;
+    pauseRecording(options?: RecordingOwnershipOptions): Promise<HeartRateRecordingState>;
+    resumeRecording(options?: RecordingOwnershipOptions): Promise<HeartRateRecordingState>;
     /** Ends the recording and hands back every reading it kept. */
-    stopRecording: () => Promise<HeartRateRecordingState & {
+    stopRecording(options?: RecordingOwnershipOptions): Promise<HeartRateRecordingState & {
         samples: HeartRateSample[];
     }>;
-    getRecordingState: () => Promise<HeartRateRecordingState>;
+    getRecordingState(options?: RecordingOwnershipOptions): Promise<HeartRateRecordingState>;
+    acknowledgeRecording(options: RecordingOwnershipOptions): Promise<boolean>;
     /** The recording so far; only what came after `since` (ms) when given. */
-    readRecording: (options?: {
+    readRecording(options?: {
         since?: number;
-    }) => Promise<HeartRateSample[]>;
+        expectedId?: string;
+    }): Promise<HeartRateSample[]>;
     /** Every reading from the connected strap, about once a second. */
     onReading: (callback: (reading: HeartRateReading) => void) => (() => void);
     /** Each strap a scan finds. */
@@ -1685,6 +1718,8 @@ export declare const watchConnectivity: {
     onReachabilityChange(callback: (reachable: boolean) => void): () => void;
 };
 declare const mobile: {
+    crypto: typeof crypto;
+    storage: typeof storage;
     device: typeof device;
     haptics: typeof haptics;
     permissions: typeof permissions;

package/dist/browser/storage.d.ts

@@ -6,8 +6,11 @@ export interface BrowserStorageOptions {
     accountKeys?: string[];
     hash: (value: string) => Promise<string>;
     changed: (name: string) => void;
+    /** A host lock primitive; browsers use their native Web Locks implementation. */
+    lock?: (<T>(name: string, operation: () => T | Promise<T>) => Promise<T>) | null;
 }
 export interface BrowserStorage {
+    atomicStorage: boolean;
     craft: {
         storage: {
             getSync: (key: string) => unknown;