craft-native 0.0.278 → 0.0.293

package/README.md

@@ -668,3 +668,19 @@ Browser audio assigns one owner per sound ID. A newer play or stop invalidates
 pending media resolution for that ID; stopping all sounds, changing accounts,
 aborting a call or disposing the host also releases active audio. Superseded
 play calls reject with `AbortError`.
+
+### Packaging sandboxed macOS apps
+
+Pass `macos.appBundlePath` to package a complete STX app without discarding its
+resources. Distribution options also apply to prebuilt bundles: `buildNumber`,
+`provisioningProfile`, `privacyManifest`, and the icon are embedded before signing.
+Craft signs nested Mach-O code before the main bundle and verifies the result.
+Use `helperEntitlements` for a compiled backend's runtime permissions; App Store
+helpers inherit the main sandbox by default. `signingKeychain` selects the
+keychain for both application and installer identities.
+
+Craft's bundled-backend host reads `backend: { executable: 'stx-backend' }` from
+`Contents/Resources/craft.json`. The native app remains the main process, starts
+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.

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

@@ -10,6 +10,10 @@ export interface AndroidEmulatorOptions {
     acceptLicenses?: boolean;
     /** Defaults to 10 minutes; hardware is capped there, software cold provisioning at 20 minutes. */
     bootTimeoutMs?: number;
+    /** Requested guest RAM, 1536–8192 MB (Android emulator limits); defaults to 2048. */
+    memoryMb?: number;
+    /** Requested guest CPU count, 1–8; defaults to 2. */
+    virtualCpus?: number;
     env?: Record<string, string | undefined>;
 }
 export interface AndroidEmulatorSession {

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

@@ -177,7 +177,7 @@ export interface CraftAndroidConfig {
     };
 }
 /** The shared health data types (the iOS builder's HealthKit names). */
-export type HealthConnectType = 'steps' | 'heartRate' | 'activeEnergy' | 'distance' | 'workouts' | 'restingHeartRate' | 'heartRateVariability' | 'bodyMass' | 'sleep' | 'mindful' | 'dietaryEnergy' | 'dietaryProtein' | 'dietaryCarbohydrates' | 'dietaryFat';
+export type HealthConnectType = 'steps' | 'heartRate' | 'activeEnergy' | 'distance' | 'workouts' | 'restingHeartRate' | 'heartRateVariability' | 'bodyMass' | 'sleep' | 'mindful' | 'dietaryEnergy' | 'dietaryProtein' | 'dietaryCarbohydrates' | 'dietaryFat' | 'bloodGlucose' | 'insulinDelivery';
 /**
  * The Health Connect permissions behind each type, for reading and for
  * writing. CraftNativeHealth.kt asks for the same ones; a permission the

package/dist/android/src/index.js

@@ -198,6 +198,12 @@ async function createAndroidEmulator(options) {
   const maximumBootTimeoutMs = options.acceleration === "software" ? 1200000 : 600000;
   if (!Number.isSafeInteger(bootTimeoutMs) || bootTimeoutMs < 1000 || bootTimeoutMs > maximumBootTimeoutMs)
     throw new Error(`Android bootTimeoutMs must be an integer between 1000 and ${maximumBootTimeoutMs} milliseconds`);
+  const memoryMb = options.memoryMb ?? 2048;
+  if (!Number.isSafeInteger(memoryMb) || memoryMb < 1536 || memoryMb > 8192)
+    throw new Error("Android memoryMb must be an integer between 1536 and 8192 megabytes");
+  const virtualCpus = options.virtualCpus ?? 2;
+  if (!Number.isSafeInteger(virtualCpus) || virtualCpus < 1 || virtualCpus > 8)
+    throw new Error("Android virtualCpus must be an integer between 1 and 8");
   const port = options.port ?? 5558;
   if (!Number.isInteger(port) || port < 5554 || port > 5682 || port % 2 !== 0)
     throw new Error("Android console ports must be even and between 5554 and 5682");
@@ -299,7 +305,7 @@ async function createAndroidEmulator(options) {
     const hostCpus = cpus();
     cpuStart = hostCpus.reduce((total, cpu) => total + Object.values(cpu.times).reduce((sum, value) => sum + value, 0), 0);
     idleStart = hostCpus.reduce((total, cpu) => total + cpu.times.idle, 0);
-    child = Bun.spawn([executable, "-avd", name, "-port", String(port), "-no-window", "-no-snapshot", "-no-audio", "-no-boot-anim", "-gpu", "software", "-memory", "2048", "-cores", "2", "-accel", options.acceleration === "software" ? "off" : "on"], { env, stdout: log, stderr: log });
+    child = Bun.spawn([executable, "-avd", name, "-port", String(port), "-no-window", "-no-snapshot", "-no-audio", "-no-boot-anim", "-gpu", "software", "-memory", String(memoryMb), "-cores", String(virtualCpus), "-accel", options.acceleration === "software" ? "off" : "on"], { env, stdout: log, stderr: log });
     identity = {
       image: options.image,
       acceleration: options.acceleration,
@@ -307,8 +313,8 @@ async function createAndroidEmulator(options) {
       bootTimeoutMs,
       bootStartedAt: new Date(bootStartedAt).toISOString(),
       host: { cpuModel: hostCpus[0]?.model, logicalCpus: hostCpus.length, availableParallelism: availableParallelism(), memoryBytes: totalmem() },
-      virtualCpus: 2,
-      memoryMb: 2048,
+      virtualCpus,
+      memoryMb,
       serial,
       avdDirectory: env.ANDROID_AVD_HOME,
       emulatorPid: child.pid
@@ -335,11 +341,13 @@ async function createAndroidEmulator(options) {
           const packages = await run([adb, "-s", serial, "shell", "pm", "path", "android"], undefined, probeTimeout(), true);
           const playStore = requiresPlayStore ? await run([adb, "-s", serial, "shell", "pm", "path", "com.android.vending"], undefined, probeTimeout(), true) : undefined;
           const systemUi = await run([adb, "-s", serial, "shell", "pidof", "com.android.systemui"], undefined, probeTimeout(), true);
-          const events = await run([adb, "-s", serial, "logcat", "-b", "events", "-d", "-t", "1"], undefined, probeTimeout(), true);
+          const events = await run([adb, "-s", serial, "logcat", "-b", "events", "-d", "-v", "threadtime"], undefined, probeTimeout(), true);
           const home = await run([adb, "-s", serial, "shell", "cmd", "package", "resolve-activity", "--brief", "-a", "android.intent.action.MAIN", "-c", "android.intent.category.HOME"], undefined, probeTimeout(), true);
           const homeActivity = home.stdout.trim().split(/\r?\n/).at(-1) ?? "";
           const temporaryHome = homeActivity.startsWith("com.android.sdksetup/") || homeActivity.startsWith("com.google.android.googlesdksetup/") || /^com\.android\.settings\/(?:\.|com\.android\.settings\.)FallbackHome$/.test(homeActivity) || /^android\/.*(?:Resolver|Chooser)Activity$/.test(homeActivity);
-          booted = settings.code === 0 && packages.code === 0 && systemUi.code === 0 && events.code === 0 && /^package:\/\S+/m.test(packages.stdout) && /^\d+(?:\s+\d+)*$/.test(systemUi.stdout.trim()) && (!requiresPlayStore || playStore?.code === 0 && /^package:\/\S+/m.test(playStore.stdout)) && home.code === 0 && /^[\w.]+\/[\w.$]+$/.test(homeActivity) && !temporaryHome;
+          const windows = await run([adb, "-s", serial, "shell", "dumpsys", "window"], undefined, probeTimeout(), true);
+          const focusedPackage = windows.stdout.match(/^\s*mCurrentFocus\s*=\s*Window\{[^}\r\n]*\bu\d+\s+([\w.]+)\//m)?.[1];
+          booted = settings.code === 0 && packages.code === 0 && systemUi.code === 0 && events.code === 0 && /^package:\/\S+/m.test(packages.stdout) && /^\d+(?:\s+\d+)*$/.test(systemUi.stdout.trim()) && (!requiresPlayStore || playStore?.code === 0 && /^package:\/\S+/m.test(playStore.stdout)) && home.code === 0 && /^[\w.]+\/[\w.$]+$/.test(homeActivity) && !temporaryHome && windows.code === 0 && focusedPackage === homeActivity.split("/")[0];
         }
       }
       const checkedAt = Date.now();
@@ -472,7 +480,9 @@ var HEALTH_CONNECT_PERMISSIONS = {
   dietaryEnergy: { read: ["READ_NUTRITION"], write: ["WRITE_NUTRITION"] },
   dietaryProtein: { read: ["READ_NUTRITION"], write: ["WRITE_NUTRITION"] },
   dietaryCarbohydrates: { read: ["READ_NUTRITION"], write: ["WRITE_NUTRITION"] },
-  dietaryFat: { read: ["READ_NUTRITION"], write: ["WRITE_NUTRITION"] }
+  dietaryFat: { read: ["READ_NUTRITION"], write: ["WRITE_NUTRITION"] },
+  bloodGlucose: { read: ["READ_BLOOD_GLUCOSE"], write: [] },
+  insulinDelivery: { read: [], write: [] }
 };
 var DEFAULT_HEALTH_CONNECT = { read: ["steps", "heartRate", "activeEnergy", "distance", "workouts"], write: ["workouts"] };
 function healthConnectPermissions(config) {
@@ -845,6 +855,7 @@ function writeNativeShellSources(output, packagePath, packageName, config) {
   };
   write("CraftBluetooth.kt.template", "CraftBluetooth.kt");
   write("CraftNativeShell.kt.template", "CraftNativeShell.kt");
+  write("CraftSnapshotFile.kt.template", "CraftSnapshotFile.kt");
   write("CraftNativeImageCache.kt.template", "CraftNativeImageCache.kt");
   write("CraftNativeHaptics.kt.template", "CraftNativeHaptics.kt");
   write("CraftNativeBackground.kt.template", "CraftNativeBackground.kt");

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

@@ -17,6 +17,7 @@ import androidx.health.connect.client.aggregate.AggregationResult
 import androidx.health.connect.client.feature.ExperimentalMindfulnessSessionApi
 import androidx.health.connect.client.permission.HealthPermission
 import androidx.health.connect.client.records.ActiveCaloriesBurnedRecord
+import androidx.health.connect.client.records.BloodGlucoseRecord
 import androidx.health.connect.client.records.DistanceRecord
 import androidx.health.connect.client.records.ElevationGainedRecord
 import androidx.health.connect.client.records.ExerciseSessionRecord
@@ -162,6 +163,10 @@ internal class CraftNativeHealth(
                 getDailyStatistics(type, options(1))
             }
             "getHeartRateSamples" -> answer(completion) { getHeartRateSamples(options(0)) }
+            "getSamples" -> answer(completion) {
+                val type = args.opt(0) as? String ?: throw invalid("getSamples needs a type")
+                getSamples(type, options(1))
+            }
             "getSleepIntervals" -> answer(completion) { getSleepIntervals(options(0)) }
             "saveMindfulSession" -> answer(completion) { saveMindfulSession(options(0)) }
             "getMindfulSessions" -> answer(completion) { getMindfulSessions(options(0)) }
@@ -438,7 +443,8 @@ internal class CraftNativeHealth(
     /** The types whose every read permission is granted, in the order of TYPES. */
     private suspend fun grantedTypes(): Any {
         val granted = client().permissionController.getGrantedPermissions()
-        return JSONArray(TYPES.filter { type -> granted.containsAll(readPermissions(type)) })
+        // A type Health Connect cannot hold (insulin) is never granted.
+        return JSONArray(TYPES.filter { type -> readPermissions(type).let { it.isNotEmpty() && granted.containsAll(it) } })
     }
 
     /**
@@ -783,6 +789,53 @@ internal class CraftNativeHealth(
         return rows
     }
 
+    /**
+     * Every glucose reading or carb entry between two instants, oldest first,
+     * as the writing app saved it: its record id (so a sync stores it once),
+     * value, source and device. Glucose comes in mg/dL with its meal relation
+     * and specimen when the source said. Health Connect has no insulin type,
+     * so `insulinDelivery` answers an empty list rather than failing a sync
+     * that asks for all three.
+     */
+    private suspend fun getSamples(type: String, options: JSONObject): Any {
+        if (type !in SAMPLE_TYPES) throw invalid("getSamples reads bloodGlucose, insulinDelivery or dietaryCarbohydrates")
+        val end = options.instant("endDate") ?: Instant.now()
+        val start = options.instant("startDate") ?: end.minus(Duration.ofDays(7))
+        val cap = (options.int("limit") ?: 10_000).coerceIn(1, 50_000)
+        val rows = JSONArray()
+        if (type == "insulinDelivery") return rows
+        val client = client()
+        fun row(id: String, value: Double, unit: String, from: Instant, to: Instant, metadata: Metadata): JSONObject {
+            val origin = metadata.dataOrigin.packageName
+            val item = JSONObject()
+                .put("id", id)
+                .put("value", value)
+                .put("unit", unit)
+                .put("startDate", from.ms())
+                .put("endDate", to.ms())
+                .put("sourceName", sourceName(origin))
+                .put("sourceBundleId", origin)
+                .put("ownApp", origin == context.packageName)
+            putDevice(item, metadata.device, withModel = false)
+            return item
+        }
+        if (type == "bloodGlucose") {
+            for (record in readAll(client, BloodGlucoseRecord::class, range(start, end), cap = cap)) {
+                val item = row(record.metadata.id, record.level.inMilligramsPerDeciliter, "mg/dL", record.time, record.time, record.metadata)
+                mealTimeName(record.relationToMeal)?.let { item.put("mealTime", it) }
+                specimenName(record.specimenSource)?.let { item.put("specimen", it) }
+                rows.put(item)
+            }
+            return rows
+        }
+        for (record in readAll(client, NutritionRecord::class, range(start, end), cap = cap)) {
+            val grams = record.totalCarbohydrate?.inGrams ?: continue
+            if (grams <= 0) continue
+            rows.put(row(record.metadata.id, grams, "g", record.startTime, record.endTime, record.metadata))
+        }
+        return rows
+    }
+
     /**
      * Sleep between two instants, oldest first, as the sources wrote it: each
      * stage with its name and whether it counts as asleep. A session with no
@@ -996,7 +1049,28 @@ internal class CraftNativeHealth(
             "steps", "heartRate", "activeEnergy", "distance", "workouts", "restingHeartRate",
             "heartRateVariability", "bodyMass", "sleep", "mindful",
             "dietaryEnergy", "dietaryProtein", "dietaryCarbohydrates", "dietaryFat",
+            "bloodGlucose", "insulinDelivery",
         )
+        /** What `getSamples` reads one record at a time. */
+        private val SAMPLE_TYPES = setOf("bloodGlucose", "insulinDelivery", "dietaryCarbohydrates")
+
+        private fun mealTimeName(relation: Int): String? = when (relation) {
+            BloodGlucoseRecord.RELATION_TO_MEAL_BEFORE_MEAL -> "beforeMeal"
+            BloodGlucoseRecord.RELATION_TO_MEAL_AFTER_MEAL -> "afterMeal"
+            BloodGlucoseRecord.RELATION_TO_MEAL_FASTING -> "fasting"
+            BloodGlucoseRecord.RELATION_TO_MEAL_GENERAL -> "general"
+            else -> null
+        }
+
+        private fun specimenName(source: Int): String? = when (source) {
+            BloodGlucoseRecord.SPECIMEN_SOURCE_CAPILLARY_BLOOD -> "capillaryBlood"
+            BloodGlucoseRecord.SPECIMEN_SOURCE_INTERSTITIAL_FLUID -> "interstitialFluid"
+            BloodGlucoseRecord.SPECIMEN_SOURCE_PLASMA -> "plasma"
+            BloodGlucoseRecord.SPECIMEN_SOURCE_SERUM -> "serum"
+            BloodGlucoseRecord.SPECIMEN_SOURCE_TEARS -> "tears"
+            BloodGlucoseRecord.SPECIMEN_SOURCE_WHOLE_BLOOD -> "wholeBlood"
+            else -> null
+        }
         private val DIETARY_TYPES = setOf("dietaryEnergy", "dietaryProtein", "dietaryCarbohydrates", "dietaryFat")
 
         private val AWAKE_STAGES = setOf(
@@ -1142,6 +1216,8 @@ internal class CraftNativeHealth(
             "sleep" -> setOf(HealthPermission.getReadPermission(SleepSessionRecord::class))
             "mindful" -> setOf(HealthPermission.getReadPermission(MindfulnessSessionRecord::class))
             in DIETARY_TYPES -> setOf(HealthPermission.getReadPermission(NutritionRecord::class))
+            "bloodGlucose" -> setOf(HealthPermission.getReadPermission(BloodGlucoseRecord::class))
+            // Health Connect has no insulin record: nothing to ask for.
             else -> emptySet()
         }
 

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

@@ -270,7 +270,12 @@ internal object CraftNativeStorage {
 
 }
 
-internal class CraftNativeStores private constructor(context: Context, private val secureEnabled: Boolean) {
+internal class CraftNativeStores private constructor(
+    context: Context,
+    private val secureEnabled: Boolean,
+    private val snapshotFiles: CraftSnapshotFile,
+) {
+    private constructor(context: Context, secureEnabled: Boolean) : this(context, secureEnabled, CraftSnapshotFile())
     private val appContext = context.applicationContext
     private val storage: SharedPreferences = appContext.getSharedPreferences("craft-native-storage", Context.MODE_PRIVATE)
     private val snapshotsDir = File(appContext.filesDir, "craft-snapshots").apply { mkdirs() }
@@ -355,20 +360,22 @@ internal class CraftNativeStores private constructor(context: Context, private v
     fun setSnapshot(name: String, json: String?, from: String?, done: (Boolean) -> Unit) {
         writer.execute {
             val file = snapshotFile(name)
+            val previous = snapshotCache[name]
             val ok = runCatching {
                 if (json == null) {
                     !file.exists() || file.delete()
                 } else {
-                    val temporary = File(file.parentFile, "${file.name}.tmp")
-                    temporary.writeText(json)
-                    temporary.renameTo(file) || run { file.writeText(json); temporary.delete(); true }
+                    snapshotFiles.set(file, json)
+                    true
                 }
             }.getOrDefault(false)
             if (ok) {
                 if (json == null) snapshotCache.remove(name) else snapshotCache[name] = json
             }
             main.post {
-                if (ok) changed("snapshots", name, json, null)
+                // Isolates optimistically display their write. Restore the
+                // confirmed value before rejecting an unsuccessful checkpoint.
+                changed("snapshots", name, if (ok) json else previous, null)
                 done(ok)
             }
         }

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

@@ -0,0 +1,26 @@
+package {{PACKAGE_NAME}}
+
+import java.io.File
+import java.io.FileOutputStream
+import java.nio.file.Files
+import java.nio.file.StandardCopyOption
+import java.util.UUID
+
+/** One checkpoint replacement. Filesystem failures must leave the previous checkpoint intact. */
+internal class CraftSnapshotFile(
+    private val write: (File, ByteArray) -> Unit = { file, bytes ->
+        FileOutputStream(file).use { stream -> stream.write(bytes); stream.fd.sync() }
+    },
+    private val replace: (File, File) -> Unit = { source, destination ->
+        Files.move(source.toPath(), destination.toPath(), StandardCopyOption.ATOMIC_MOVE, StandardCopyOption.REPLACE_EXISTING)
+    },
+) {
+    fun set(destination: File, json: String) {
+        val temporary = File(destination.parentFile, ".craft-snapshot-${UUID.randomUUID()}.tmp")
+        val bytes = json.toByteArray(Charsets.UTF_8)
+        try {
+            write(temporary, bytes)
+            replace(temporary, destination)
+        } finally { temporary.delete() }
+    }
+}

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

@@ -4661,6 +4661,7 @@ class MainActivity : AppCompatActivity() {
             capabilities: ${capabilityNames()},
             initialAppState: ${JSONObject.quote(nativeAppState)},
             colorScheme: ${JSONObject.quote(colorScheme())},
+            viewportWidth: ${resources.configuration.screenWidthDp},
             appearance: ${appearance()},
             appURL: ${JSONObject.quote(config.optString("devServerURL"))},
             appVersion: ${JSONObject.quote(appVersion().first)},
@@ -4909,6 +4910,21 @@ class MainActivity : AppCompatActivity() {
     override fun onConfigurationChanged(newConfig: Configuration) {
         super.onConfigurationChanged(newConfig)
         publishAppearance()
+        publishViewport(newConfig)
+    }
+
+    /// The width the screens last heard, in dp (a web page's CSS pixels).
+    private var reportedViewportWidth = -1
+
+    /// Rotation, split screen or a resized window: the bundle's width classes
+    /// (`md:`, `lg:`) follow the window's new width.
+    private fun publishViewport(config: Configuration) {
+        val width = config.screenWidthDp
+        if (width <= 0 || width == reportedViewportWidth) return
+        reportedViewportWidth = width
+        if (!::root.isInitialized) return
+        val payload = JSONObject().put("width", width).put("height", config.screenHeightDp)
+        allScreens().forEach { screen -> if (!screen.headless) send(screen, "VIEWPORT", payload) }
     }
 
     private fun publishAppearance() {

package/dist/api/mobile.d.ts

@@ -1546,11 +1546,48 @@ export type HealthDataType = 'steps' | 'heartRate' | 'activeEnergy' | 'distance'
 /** Food logged by any app, per day: kcal eaten, then grams of protein, carbohydrate and fat. */
  | 'dietaryEnergy' | 'dietaryProtein' | 'dietaryCarbohydrates' | 'dietaryFat'
 /** Mindful minutes (meditation, breathing): read with getMindfulSessions, written with saveMindfulSession. */
- | 'mindful';
+ | 'mindful'
+/** Blood glucose from a CGM or meter, in mg/dL: read with getSamples. Read only. */
+ | 'bloodGlucose'
+/**
+ * Insulin from a pump, pen or closed loop, in international units, each
+ * marked basal or bolus: read with getSamples. Read only. HealthKit only:
+ * Health Connect has no insulin type, so Android answers none.
+ */
+ | 'insulinDelivery';
 /** The types with one value per day. `sleep` is hours asleep, counted on the day you woke. */
-export type HealthDailyType = Exclude<HealthDataType, 'workouts' | 'mindful'>;
+export type HealthDailyType = Exclude<HealthDataType, 'workouts' | 'mindful' | 'bloodGlucose' | 'insulinDelivery'>;
 /** Quantity types that can be written with `health.saveData()`. */
-export type HealthQuantityType = Exclude<HealthDataType, 'workouts' | 'sleep' | 'mindful'>;
+export type HealthQuantityType = Exclude<HealthDataType, 'workouts' | 'sleep' | 'mindful' | 'bloodGlucose' | 'insulinDelivery'>;
+/** The types `health.getSamples()` reads one sample at a time: glucose, insulin and carbs, as a diabetes app needs them. */
+export type HealthSampleType = 'bloodGlucose' | 'insulinDelivery' | 'dietaryCarbohydrates';
+export interface HealthSamplesQuery extends HealthSampleQuery {
+    /** At most this many, oldest first. Defaults to 10000, capped at 50000. Start defaults to 7 days ago. */
+    limit?: number;
+}
+/** One glucose reading, insulin dose or carb entry as the writing app saved it. */
+export interface HealthQuantitySample {
+    /** HealthKit's UUID or Health Connect's record id: stable across reads. */
+    id: string;
+    /** In `unit`: mg/dL for glucose, IU for insulin, g for carbs. */
+    value: number;
+    unit: 'mg/dL' | 'IU' | 'g';
+    /** Epoch milliseconds. */
+    startDate: number;
+    /** Epoch milliseconds; the same as `startDate` for an instant reading. A basal delivery spans its segment. */
+    endDate: number;
+    sourceName: string;
+    sourceBundleId: string;
+    /** True when this app wrote it. */
+    ownApp: boolean;
+    deviceName?: string;
+    /** Insulin only: what the dose was for. */
+    insulinReason?: 'basal' | 'bolus';
+    /** Glucose only: when it was taken relative to a meal, when the source said. */
+    mealTime?: 'beforeMeal' | 'afterMeal' | 'fasting' | 'general';
+    /** Glucose only (Health Connect): what was sampled, when the source said. */
+    specimen?: 'capillaryBlood' | 'interstitialFluid' | 'plasma' | 'serum' | 'tears' | 'wholeBlood';
+}
 export interface HealthAuthorizationOptions {
     /** `false` asks to read only. Default: also allowed to save workouts. */
     write?: boolean;
@@ -1737,7 +1774,7 @@ export interface HealthLiveWorkoutEvent {
     message?: string;
 }
 /** The health reads and writes a host may or may not have, depending on the app build it runs in. */
-export type HealthReadMethod = 'getWorkouts' | 'getDailyStatistics' | 'getHeartRateSamples' | 'getSleepIntervals' | 'saveData' | 'saveMindfulSession' | 'getMindfulSessions' | 'startHeartRateUpdates' | 'stopHeartRateUpdates' | 'startWorkout' | 'pauseWorkout' | 'resumeWorkout' | 'endWorkout';
+export type HealthReadMethod = 'getWorkouts' | 'getDailyStatistics' | 'getHeartRateSamples' | 'getSamples' | 'getSleepIntervals' | 'saveData' | 'saveMindfulSession' | 'getMindfulSessions' | 'startHeartRateUpdates' | 'stopHeartRateUpdates' | 'startWorkout' | 'pauseWorkout' | 'resumeWorkout' | 'endWorkout';
 export declare const health: {
     /**
      * Whether this app build answers `method`. An app installed before a read
@@ -1760,6 +1797,13 @@ export declare const health: {
     getDailyStatistics(type: HealthDailyType, options?: HealthDataOptions): Promise<HealthDailyValue[]>;
     /** Every heart-rate reading between two instants, oldest first. iOS only for now. */
     getHeartRateSamples(options?: HealthHeartRateQuery): Promise<HealthHeartRateSample[]>;
+    /**
+     * Every glucose reading, insulin dose or carb entry between two instants,
+     * oldest first, each with its own id so a sync can store it once. Needs
+     * the type's read grant. Health Connect has no insulin, so Android answers
+     * an empty list for `insulinDelivery`.
+     */
+    getSamples(type: HealthSampleType, options?: HealthSamplesQuery): Promise<HealthQuantitySample[]>;
     /** Sleep between two instants, oldest first: time in bed and each asleep or awake stage. iOS only for now. */
     getSleepIntervals(options?: HealthSampleQuery): Promise<HealthSleepInterval[]>;
     /**

package/dist/browser/storage.d.ts

@@ -17,8 +17,10 @@ export interface BrowserStorageOptions {
      * or in another tab: called once the new account's storage is in place.
      */
     sessionChanged?: (token: string | null, previous: string | null) => void;
-    /** A host lock primitive; browsers use their native Web Locks implementation. */
-    lock?: (<T>(name: string, operation: () => T | Promise<T>) => Promise<T>) | null;
+    /** A host lock primitive; honor signal cancellation while queued, as native Web Locks do. */
+    lock?: (<T>(name: string, operation: () => T | Promise<T>, options?: {
+        signal?: AbortSignal;
+    }) => Promise<T>) | null;
 }
 export interface BrowserStorage {
     atomicStorage: boolean;
@@ -37,7 +39,7 @@ export interface BrowserStorage {
             keys: () => string[];
         };
     };
-    call: (module: string, method: string, args: unknown[]) => Promise<unknown>;
+    call: (module: string, method: string, args: unknown[], signal?: AbortSignal) => Promise<unknown>;
     accountChanged: () => Promise<void>;
     scope: () => string;
 }

package/dist/browser.d.ts

@@ -18,6 +18,7 @@ export interface BrowserPlatformOptions {
 export interface BrowserPlatform {
     craft: Record<string, unknown>;
     capabilities: string[];
+    /** Queued storage calls abort without writing; cancellation cannot undo an already committed synchronous write. */
     call: (module: string, method: string, args: unknown[], signal: AbortSignal) => Promise<unknown>;
     navigate: (path: string, replace?: boolean) => void;
     emit: (listener: (type: string, payload: unknown) => void) => () => void;

package/dist/browser.js

@@ -63,12 +63,35 @@ function secureUUID() {
 }
 
 // src/browser/storage.ts
+async function waitForAccount(operation, signal) {
+  if (!signal)
+    return operation;
+  let abort;
+  try {
+    return await Promise.race([operation, new Promise((resolve, reject) => {
+      abort = () => reject(signal.reason);
+      if (signal.aborted)
+        abort();
+      else
+        signal.addEventListener("abort", abort, { once: true });
+    })]);
+  } finally {
+    signal.removeEventListener("abort", abort);
+  }
+}
 async function createBrowserStorage(options) {
   const { storage, namespace, tokenKey, changed } = options;
   const sessionTokenKey = options.sessionTokenKey || "auth.token";
   const prefix = `${namespace}:`;
-  const lock = options.lock === null ? undefined : options.lock ?? (typeof navigator !== "undefined" && typeof navigator.locks?.request === "function" ? (name, operation) => navigator.locks.request(name, operation) : undefined);
-  const exclusive = (operation) => lock ? lock(`${namespace}:storage`, operation) : Promise.resolve().then(operation);
+  const lock = options.lock === null ? undefined : options.lock ?? (typeof navigator !== "undefined" && typeof navigator.locks?.request === "function" ? (name, operation, settings) => navigator.locks.request(name, settings ?? {}, operation) : undefined);
+  const exclusive = (operation, signal) => {
+    const guarded = () => {
+      signal?.throwIfAborted();
+      return operation();
+    };
+    signal?.throwIfAborted();
+    return lock ? lock(`${namespace}:storage`, guarded, { signal }) : Promise.resolve().then(guarded);
+  };
   const scopeChanged = () => Object.assign(new Error("The storage account changed"), { code: "STORAGE_SCOPE_CHANGED" });
   const pending = new Map;
   let token = storage.getItem(tokenKey);
@@ -215,10 +238,11 @@ async function createBrowserStorage(options) {
         keys: () => available() ? keys(key("snapshot:")).map((name) => name.slice(key("snapshot:").length)) : []
       }
     },
-    async call(module, method, args) {
+    async call(module, method, args, signal) {
+      signal?.throwIfAborted();
       const captured = capture();
       const wasAvailable = available();
-      await accountChanged();
+      await waitForAccount(accountChanged(), signal);
       const name = String(args[0] ?? "");
       if (module === "Storage") {
         if (!wasAvailable)
@@ -259,7 +283,7 @@ async function createBrowserStorage(options) {
             return true;
           }
           throw Object.assign(new Error(`Unsupported browser storage operation ${method}`), { code: "UNSUPPORTED" });
-        });
+        }, signal);
       }
       if (module === "SecureStorage") {
         if (!wasAvailable)
@@ -284,7 +308,7 @@ async function createBrowserStorage(options) {
             return true;
           }
           throw Object.assign(new Error(`Unsupported browser storage operation ${module}.${method}`), { code: "UNSUPPORTED" });
-        });
+        }, signal);
         if (method === "clear" || name === sessionTokenKey && (method === "set" || method === "remove"))
           await accountChanged();
         return result;
@@ -608,7 +632,7 @@ async function createBrowserPlatform(options = {}) {
       const first = object(args[0]);
       if (module === "Storage" || module === "SecureStorage") {
         const before = persistence.craft.secureStorage.getSync(sessionTokenKey);
-        const answer = await persistence.call(module, method, args);
+        const answer = await persistence.call(module, method, args, signal);
         if (before !== persistence.craft.secureStorage.getSync(sessionTokenKey))
           await resetAccount();
         return answer;