craft-native 0.0.290 → 0.0.296

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

@@ -45,6 +45,10 @@ export interface CraftAndroidConfig {
     renderer?: 'web' | 'native';
     /** "system" follows the device; light/dark pin the generated host. */
     appearance?: 'light' | 'dark' | 'system';
+    /** Static native tab-bar styling applied before the page's own tabBar.set call. */
+    tabBar?: CraftTabBarConfig;
+    /** Runs from the generated project root before Gradle compiles the app. */
+    postGenerate?: CraftPostGenerateHook;
     version?: string;
     versionCode?: number;
     darkMode?: boolean;
@@ -176,8 +180,21 @@ export interface CraftAndroidConfig {
         sessions?: boolean;
     };
 }
+export interface CraftTabBarConfig {
+    selection?: {
+        /** The selected tab indicator's corner radius in dp; omitted keeps the default. */
+        cornerRadius?: number;
+        /** The selected tab indicator fill as #RRGGBB. */
+        color?: string;
+    };
+}
+/** A declared command Craft runs after the native project has been generated. */
+export interface CraftPostGenerateHook {
+    command: string;
+    args?: string[];
+}
 /** 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
@@ -227,6 +244,13 @@ export interface BuildOptions {
     /** Same meaning as `InitOptions.runtimeDir`; refreshes what init installed. */
     runtimeDir?: string | null;
 }
+/**
+ * Run the app's declared generator hook without invoking a shell.
+ *
+ * A hook gets the generated project as its cwd and explicit metadata so a
+ * patch can target the right platform and phase without guessing from paths.
+ */
+export declare function runPostGenerateHook(hook: CraftPostGenerateHook | undefined, output: string, phase?: 'build'): void;
 export interface OpenOptions {
     output: string;
 }

package/dist/android/src/index.js

@@ -480,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) {
@@ -505,6 +507,30 @@ function healthConnectPermissions(config) {
     permissions.add("android.permission.health.READ_HEALTH_DATA_HISTORY");
   return [...permissions];
 }
+function runPostGenerateHook(hook, output, phase = "build") {
+  if (!hook)
+    return;
+  if (typeof hook.command !== "string" || !hook.command.trim())
+    throw new Error("Android postGenerate.command must be a non-empty executable");
+  if (hook.args !== undefined && (!Array.isArray(hook.args) || hook.args.some((argument) => typeof argument !== "string")))
+    throw new Error("Android postGenerate.args must be an array of strings");
+  const command = [hook.command, ...hook.args ?? []];
+  let result;
+  try {
+    result = Bun.spawnSync(command, {
+      cwd: output,
+      env: { ...process.env, CRAFT_PROJECT_ROOT: output, CRAFT_PLATFORM: "android", CRAFT_GENERATE_PHASE: phase },
+      stdout: "inherit",
+      stderr: "pipe"
+    });
+  } catch (error) {
+    throw new Error(`Android postGenerate hook could not start in ${output}: ${hook.command}`, { cause: error });
+  }
+  if (result.exitCode !== 0) {
+    const stderr = result.stderr?.toString().trim();
+    throw new Error(`Android postGenerate hook failed in ${output} with exit code ${result.exitCode}${stderr ? `: ${stderr}` : ""}`);
+  }
+}
 var DEFAULT_CONFIG = {
   renderer: "web",
   version: "1.0.0",
@@ -632,6 +658,11 @@ function validateAndroidConfig(config) {
   if (config.appearance !== undefined && !["light", "dark", "system"].includes(config.appearance)) {
     throw new Error(`Unknown Android appearance: ${config.appearance}. Expected light, dark, or system.`);
   }
+  const selection = config.tabBar?.selection;
+  if (selection?.cornerRadius !== undefined && (!Number.isFinite(selection.cornerRadius) || selection.cornerRadius < 0))
+    throw new Error("Android tabBar.selection.cornerRadius must be a finite non-negative number");
+  if (selection?.color !== undefined && !/^#[0-9a-f]{6}$/i.test(selection.color))
+    throw new Error("Android tabBar.selection.color must be a #RRGGBB color");
   const packageSegments = config.packageName.split(".");
   if (packageSegments.length < 2 || packageSegments.some((segment) => !/^[A-Za-z_][A-Za-z0-9_]*$/.test(segment) || KOTLIN_KEYWORDS.has(segment))) {
     throw new Error(`Invalid Android package name: ${config.packageName}`);
@@ -1396,6 +1427,7 @@ async function build(options) {
     console.log(`   Synced: ${htmlPath} \u2192 assets/`);
   }
   syncNativeFonts(config.nativeFonts, output);
+  runPostGenerateHook(config.postGenerate, output);
   if (!compile)
     return;
   const gradlewPath = join3(output, "gradlew");
@@ -1484,6 +1516,7 @@ export {
   resolveRuntimeDir,
   run,
   runKotlinFixture,
+  runPostGenerateHook,
   syncAndroidWebAssets,
   syncNativeFonts
 };

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

@@ -86,6 +86,11 @@ internal data class CraftNativeTab(
     val selectedSymbol: String? = null, val selectedIconTint: String? = null, val selectedIconPulse: Boolean? = null,
 )
 
+internal data class CraftNativeTabBarAppearance(
+    val selectionColor: String? = null,
+    val selectionCornerRadius: Float? = null,
+)
+
 internal data class CraftTabIconAppearance(val symbol: String, val tint: Int?, val pulse: Boolean)
 
 /** The app's paths (`nativeScreens`), its tabs and its site. */
@@ -122,6 +127,16 @@ internal class CraftNativeRoutes(config: JSONObject) {
         }
     }
 
+    val tabBarAppearance: CraftNativeTabBarAppearance = config.optJSONObject("tabBar")
+        ?.optJSONObject("selection")
+        ?.let { selection ->
+            CraftNativeTabBarAppearance(
+                selection.optString("color").takeIf { it.isNotBlank() },
+                (selection.opt("cornerRadius") as? Number)?.toFloat()?.takeIf { it.isFinite() && it >= 0 },
+            )
+        }
+        ?: CraftNativeTabBarAppearance()
+
     /** The app's site (`devServerURL`): its origin answers paths no screen draws. */
     val site: Uri? = config.optString("devServerURL").takeIf { it.isNotBlank() }?.let(Uri::parse)
     val siteOrigin: String? = site?.let { uri ->
@@ -755,7 +770,11 @@ internal object CraftNativePrelude {
  * `craft.navigation.setOptions` (title, largeTitle, hidden, rightButtons,
  * tabAccessory, tabBarHidden); the tabs come from the app's `tabs`.
  */
-internal class CraftNativeChrome(context: Context, private val tabs: List<CraftNativeTab>) : LinearLayout(context) {
+internal class CraftNativeChrome(
+    context: Context,
+    private val tabs: List<CraftNativeTab>,
+    private val tabBarAppearance: CraftNativeTabBarAppearance = CraftNativeTabBarAppearance(),
+) : LinearLayout(context) {
     val content = FrameLayout(context)
     private val bar = LinearLayout(context)
     private val backButton = ImageView(context)
@@ -1099,6 +1118,7 @@ internal class CraftNativeChrome(context: Context, private val tabs: List<CraftN
         accessorySpec?.let { accessoryIcon.setImageDrawable(CraftNativeIcons.drawable(context, null, it.optString("symbol"), text)) }
         tabViews.forEachIndexed { index, (icon, label) ->
             tabBar.getChildAt(index).isSelected = index == selectedTab
+            tabBar.getChildAt(index).background = tabCellBackground(index, dark)
             val color = if (index == selectedTab) accent else muted
             val id = tabs[index].id
             val number = tabIconText[id]
@@ -1188,6 +1208,17 @@ internal class CraftNativeChrome(context: Context, private val tabs: List<CraftN
 
     private fun accentColor(dark: Boolean): Int = if (dark) Color.parseColor("#0A84FF") else Color.parseColor("#007AFF")
 
+    private fun tabCellBackground(index: Int, dark: Boolean): android.graphics.drawable.Drawable? {
+        if (index != selectedTab || (tabBarAppearance.selectionColor == null && tabBarAppearance.selectionCornerRadius == null)) return rippleBackground()
+        val color = tabBarAppearance.selectionColor?.let { runCatching { Color.parseColor(it) }.getOrNull() }
+            ?: if (dark) Color.argb(42, 255, 255, 255) else Color.argb(23, 0, 0, 0)
+        val radius = tabBarAppearance.selectionCornerRadius?.let { (it * density).toInt().toFloat() } ?: dp(32).toFloat()
+        return GradientDrawable().apply {
+            setColor(color)
+            cornerRadius = radius
+        }
+    }
+
     private fun rippleBackground(): android.graphics.drawable.Drawable? {
         val value = TypedValue()
         return if (context.theme.resolveAttribute(android.R.attr.selectableItemBackgroundBorderless, value, true)) {

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

@@ -4198,7 +4198,7 @@ class MainActivity : AppCompatActivity() {
     }
 
     private fun installChrome() {
-        val bars = CraftNativeChrome(this, routes.tabs)
+        val bars = CraftNativeChrome(this, routes.tabs, routes.tabBarAppearance)
         bars.layoutParams = FrameLayout.LayoutParams(-1, -1)
         bars.onBack = { onBackPressedDispatcherCompat() }
         bars.onAccessory = { path -> navigateOpen(path) }

package/dist/api/app.d.ts

@@ -361,11 +361,11 @@ declare class AppManager {
      */
     isShortcutRegistered(accelerator: string): Promise<boolean>;
     /**
-     * Set app appearance (macOS)
+     * Set the app appearance on native hosts.
      */
     setAppearance(appearance: 'light' | 'dark' | 'system'): Promise<void>;
     /**
-     * Get current appearance
+     * Get the current effective Light/Dark appearance.
      */
     getAppearance(): Promise<'light' | 'dark'>;
     /**

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/cli.js

@@ -2945,7 +2945,7 @@ function pinCraftNativeDependency(packagePath, craftVersion) {
 `);
 }
 // package.json
-var version = "0.0.290";
+var version = "0.0.296";
 
 // bin/cli.ts
 var spawnedFrom = process6.env[CRAFT_CLI_SPAWN_MARKER];

package/dist/index.cjs

@@ -374,7 +374,7 @@ function craftBinaryNotFoundMessage(triedPath) {
 `);
 }
 // package.json
-var version = "0.0.290";
+var version = "0.0.296";
 
 // src/sdk-version.ts
 var SDK_VERSION = version;

package/dist/index.js

@@ -117,7 +117,7 @@ function craftBinaryNotFoundMessage(triedPath) {
 `);
 }
 // package.json
-var version = "0.0.290";
+var version = "0.0.296";
 
 // src/sdk-version.ts
 var SDK_VERSION = version;

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

@@ -9,6 +9,19 @@ export declare function syncNativeFonts(fonts: CraftConfig['nativeFonts'], outpu
 /** This package's version, which the app names in its user agent (`Craft/<version>`). */
 export declare function resolveCraftVersion(startDir?: string): string;
 export type CraftAppearance = 'light' | 'dark' | 'system';
+/** A declared command Craft runs after the native project has been generated. */
+export interface CraftPostGenerateHook {
+    command: string;
+    args?: string[];
+}
+export interface CraftTabBarConfig {
+    selection?: {
+        /** The selected tab indicator's corner radius in points; omitted keeps a capsule. */
+        cornerRadius?: number;
+        /** The selected tab indicator fill as #RRGGBB. */
+        color?: string;
+    };
+}
 export interface CraftConfig {
     appShortcuts?: CraftAppShortcut[];
     /** Bundled font files keyed by their PostScript font name, used as native fontFamily. */
@@ -29,6 +42,10 @@ export interface CraftConfig {
      * and `dark` pin one. Unset keeps the older `darkMode` switch.
      */
     appearance?: CraftAppearance;
+    /** Static native tab-bar styling applied before the page's own tabBar.set call. */
+    tabBar?: CraftTabBarConfig;
+    /** Runs from the generated project root after `craft ios build` writes it. */
+    postGenerate?: CraftPostGenerateHook;
     backgroundColor?: string;
     /** The launch and webview background while the phone is in Dark Mode. */
     backgroundColorDark?: string;
@@ -409,6 +426,13 @@ export interface BuildOptions {
      */
     runtimeDir?: string | null;
 }
+/**
+ * Run the app's declared generator hook without invoking a shell.
+ *
+ * A hook gets the generated project as its cwd and explicit metadata so a
+ * patch can target the right platform and phase without guessing from paths.
+ */
+export declare function runPostGenerateHook(hook: CraftPostGenerateHook | undefined, output: string, phase?: 'build'): void;
 export interface OpenOptions {
     output: string;
 }

package/dist/ios/src/index.js

@@ -512,6 +512,30 @@ function installNativeBundle(source, output) {
 function hasInstalledNativeBundle(output) {
   return existsSync(join3(output, "dist", "native-screen.js")) || existsSync(join3(output, "dist", "native-screens"));
 }
+function runPostGenerateHook(hook, output, phase = "build") {
+  if (!hook)
+    return;
+  if (typeof hook.command !== "string" || !hook.command.trim())
+    throw new Error("iOS postGenerate.command must be a non-empty executable");
+  if (hook.args !== undefined && (!Array.isArray(hook.args) || hook.args.some((argument) => typeof argument !== "string")))
+    throw new Error("iOS postGenerate.args must be an array of strings");
+  const command = [hook.command, ...hook.args ?? []];
+  let result;
+  try {
+    result = Bun.spawnSync(command, {
+      cwd: output,
+      env: { ...process.env, CRAFT_PROJECT_ROOT: output, CRAFT_PLATFORM: "ios", CRAFT_GENERATE_PHASE: phase },
+      stdout: "inherit",
+      stderr: "pipe"
+    });
+  } catch (error) {
+    throw new Error(`iOS postGenerate hook could not start in ${output}: ${hook.command}`, { cause: error });
+  }
+  if (result.exitCode !== 0) {
+    const stderr = result.stderr?.toString().trim();
+    throw new Error(`iOS postGenerate hook failed in ${output} with exit code ${result.exitCode}${stderr ? `: ${stderr}` : ""}`);
+  }
+}
 var DEFAULT_CONFIG = {
   renderer: "web",
   version: "1.0.0",
@@ -1230,6 +1254,11 @@ async function init(options) {
   if (config.renderer !== "web" && config.renderer !== "native") {
     throw new Error(`Unknown iOS renderer: ${config.renderer}. Expected web or native.`);
   }
+  const selection = config.tabBar?.selection;
+  if (selection?.cornerRadius !== undefined && (!Number.isFinite(selection.cornerRadius) || selection.cornerRadius < 0))
+    throw new Error("iOS tabBar.selection.cornerRadius must be a finite non-negative number");
+  if (selection?.color !== undefined && !/^#[0-9a-f]{6}$/i.test(selection.color))
+    throw new Error("iOS tabBar.selection.color must be a #RRGGBB color");
   if (config.enableBackgroundLocation)
     config.enableGeolocation = true;
   const problems = hybridConfigProblems(config);
@@ -1425,6 +1454,7 @@ async function build(options) {
       cause: error
     });
   }
+  runPostGenerateHook(config.postGenerate, output);
   console.log("");
 }
 async function open(options) {
@@ -1590,6 +1620,7 @@ export {
   resolveRuntimeDir,
   restoreShell,
   run,
+  runPostGenerateHook,
   serializeSimulatorSteps,
   showSimulator,
   syncNativeFonts,

package/dist/ios/templates/CraftApp.swift

@@ -102,6 +102,96 @@ enum CraftPageAppearance {
     }
 }
 
+/// The app-wide UIKit appearance override. SwiftUI's `preferredColorScheme`
+/// only controls the SwiftUI environment; native screen controllers need the
+/// UIKit override as well so their trait collection, controls and navigation
+/// chrome resolve the same way. A runtime choice is kept here so screens
+/// created after the choice inherit it instead of reverting to the bundle
+/// config.
+enum CraftInterfaceStyleController {
+    /// The app's bundled choice is the default for newly-created screens.
+    /// A runtime choice is separate: it is the only value that should
+    /// override a screen's own generated config.
+    private static var configured: UIUserInterfaceStyle = .unspecified
+    private static var runtimeSelection: UIUserInterfaceStyle?
+
+    static func configuredStyle(for config: CraftConfig) -> UIUserInterfaceStyle {
+        switch config.appearance {
+        case "system": return .unspecified
+        case "light": return .light
+        case "dark": return .dark
+        default: return config.darkMode ? .dark : .light
+        }
+    }
+
+    static func configure(_ config: CraftConfig) {
+        configured = configuredStyle(for: config)
+        runtimeSelection = nil
+        applyToWindows()
+    }
+
+    static func style(for config: CraftConfig) -> UIUserInterfaceStyle {
+        runtimeSelection ?? configuredStyle(for: config)
+    }
+
+    static func colorScheme(for config: CraftConfig) -> ColorScheme? {
+        switch style(for: config) {
+        case .light: return .light
+        case .dark: return .dark
+        default: return nil
+        }
+    }
+
+    /// Returns false rather than silently accepting a typo from JavaScript.
+    @discardableResult
+    static func set(_ value: String) -> Bool {
+        let style: UIUserInterfaceStyle
+        switch value {
+        case "system": style = .unspecified
+        case "light": style = .light
+        case "dark": style = .dark
+        default: return false
+        }
+        runtimeSelection = style
+        applyToWindows()
+        NotificationCenter.default.post(name: .craftColorSchemeChanged, object: nil)
+        return true
+    }
+
+    static func currentName() -> String {
+        let requested = runtimeSelection ?? UIApplication.shared.connectedScenes
+            .compactMap { ($0 as? UIWindowScene)?.windows.first(where: { $0.isKeyWindow })?.traitCollection.userInterfaceStyle }
+            .first ?? .unspecified
+        let style = requested == .unspecified
+            ? (UIApplication.shared.connectedScenes
+                .compactMap { ($0 as? UIWindowScene)?.windows.first(where: { $0.isKeyWindow })?.traitCollection.userInterfaceStyle }
+                .first { $0 != .unspecified } ?? UITraitCollection.current.userInterfaceStyle)
+            : requested
+        return style == .dark ? "dark" : "light"
+    }
+
+    static func apply(to controller: UIViewController, config: CraftConfig) {
+        controller.overrideUserInterfaceStyle = style(for: config)
+    }
+
+    private static func applyToWindows() {
+        let style = runtimeSelection ?? configured
+        for scene in UIApplication.shared.connectedScenes.compactMap({ $0 as? UIWindowScene }) {
+            for window in scene.windows {
+                window.overrideUserInterfaceStyle = style
+                apply(style, to: window.rootViewController)
+            }
+        }
+    }
+
+    private static func apply(_ style: UIUserInterfaceStyle, to controller: UIViewController?) {
+        guard let controller else { return }
+        controller.overrideUserInterfaceStyle = style
+        controller.children.forEach { apply(style, to: $0) }
+        if let presented = controller.presentedViewController { apply(style, to: presented) }
+    }
+}
+
 /// Tells the shell when SwiftUI's colour scheme changes: the one appearance
 /// setting with no notification of its own.
 struct CraftColorSchemeObserver: View {
@@ -195,6 +285,7 @@ struct CraftRecoveryBudget {
 final class CraftAppDelegate: NSObject, UIApplicationDelegate, UNUserNotificationCenterDelegate {
     func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]? = nil) -> Bool {
         let config = CraftConfig.bundled()
+        CraftInterfaceStyleController.configure(config)
         // First, so a crash anywhere in the rest of launch is reported too.
         CraftCrashReporter.shared.start(config)
         UNUserNotificationCenter.current().delegate = self
@@ -606,7 +697,7 @@ struct CraftApp: App {
                     .ignoresSafeArea(.keyboard, edges: .bottom)
                 }
             }
-                .preferredColorScheme(appState.config.colorScheme)
+                .preferredColorScheme(appState.appearanceScheme)
                 .environmentObject(appState)
                 .onOpenURL { url in
                     // Handle deep links and universal links
@@ -689,6 +780,10 @@ final class CraftChrome: ObservableObject {
     /// The selected tab highlight's corner radius. Nil preserves the default
     /// capsule, while a finite non-negative value opts into a rounded rect.
     private(set) var tabSelectionCornerRadius: CGFloat?
+    /// The configured static shape, retained when the page updates only its
+    /// tabs or selected item at runtime.
+    private var configuredTabSelectionCornerRadius: CGFloat?
+    private(set) var tabSelectionColor: UIColor?
 
     weak var webView: WKWebView?
     /// What the tab bar covers at the bottom of the screen, in points.
@@ -723,9 +818,13 @@ final class CraftChrome: ObservableObject {
     /// The tab bar from `tabs` in craft.config.json, there before the page
     /// loads; the page's own `tabBar` message replaces it later. `splash`
     /// false when the first screen is native and draws itself.
-    func configure(tabs configured: [CraftConfig.Tab], selected: String?, splash: Bool) {
+    func configure(tabs configured: [CraftConfig.Tab], selected: String?, splash: Bool, appearance: CraftConfig.TabBar? = nil) {
         splashVisible = splash
         tabSwipeEnabled = true
+        configuredTabSelectionCornerRadius = appearance?.selection?.cornerRadius
+            .flatMap { $0.isFinite && $0 >= 0 ? CGFloat($0) : nil }
+        tabSelectionCornerRadius = configuredTabSelectionCornerRadius
+        tabSelectionColor = appearance?.selection?.color.flatMap { UIColor(hex: $0) }
         guard !configured.isEmpty else { return }
         tabs = configured.map { Tab(id: $0.id, title: $0.title, symbol: $0.symbol ?? "circle", badge: nil, selectedSymbol: Tab.normalizedSelectedSymbol($0.selectedSymbol), selectedIconTint: $0.selectedIconTint, selectedIconPulse: $0.selectedIconPulse) }
         self.selected = selected ?? configured.first?.id
@@ -856,6 +955,7 @@ final class CraftChrome: ObservableObject {
                 tint = light.map { light in dark.map { dark in UIColor { $0.userInterfaceStyle == .dark ? dark : light } } ?? light }
             }
             if let swipeEnabled = body["swipeEnabled"] as? Bool { tabSwipeEnabled = swipeEnabled }
+            if !body.keys.contains("selection") { tabSelectionCornerRadius = configuredTabSelectionCornerRadius }
             withAnimation(Self.motion(.easeOut(duration: 0.2))) { tabBarVisible = !tabs.isEmpty && !hiddenByScreen }
             publishLayout()
         case "selectTab":
@@ -1312,6 +1412,7 @@ private struct CraftTabSelectionShape: Shape {
 }
 
 private struct CraftTabSelectionIndicator: View {
+    @ObservedObject private var chrome = CraftChrome.shared
     @ObservedObject private var progress = CraftChrome.shared.tabSwipeProgress
     let selected: Int?
     let count: Int
@@ -1323,7 +1424,7 @@ private struct CraftTabSelectionIndicator: View {
                 let width = geometry.size.width / CGFloat(max(1, count))
                 CraftTabSelectionShape(cornerRadius: cornerRadius)
                     .frame(width: width, height: geometry.size.height)
-                    .foregroundStyle(Color.primary.opacity(0.09))
+                    .foregroundStyle(chrome.tabSelectionColor.map { Color($0) } ?? Color.primary.opacity(0.09))
                     .offset(x: position * width)
             }
         }
@@ -1557,6 +1658,8 @@ class DeepLinkManager {
 // MARK: - App State
 class AppState: ObservableObject {
     @Published var config: CraftConfig
+    @Published private(set) var appearanceScheme: ColorScheme?
+    private var appearanceObserver: NSObjectProtocol?
 
     init() {
         if let configURL = Bundle.main.url(forResource: "craft.config", withExtension: "json"),
@@ -1565,11 +1668,26 @@ class AppState: ObservableObject {
         } else {
             self.config = CraftConfig()
         }
+        self.appearanceScheme = CraftInterfaceStyleController.colorScheme(for: config)
+        appearanceObserver = NotificationCenter.default.addObserver(
+            forName: .craftColorSchemeChanged,
+            object: nil,
+            queue: .main,
+        ) { [weak self] _ in
+            guard let self else { return }
+            self.appearanceScheme = CraftInterfaceStyleController.colorScheme(for: self.config)
+        }
         // Before the first frame: the hybrid start screen, and the tab bar
         // from the config, are decided here, if the app delegate has not
         // already (it does at launch; the first call decides).
         CraftHybrid.shared.configure(config)
     }
+
+    deinit {
+        if let appearanceObserver {
+            NotificationCenter.default.removeObserver(appearanceObserver)
+        }
+    }
 }
 
 extension CraftConfig {
@@ -1706,6 +1824,9 @@ struct CraftConfig: Codable {
     var nativeScreens: [String: String]? = nil
     /// The tab bar to show before the page describes its own.
     var tabs: [Tab]? = nil
+    /// Static styling for the selected tab indicator; the page may still
+    /// override its shape through `tabBar.set({ selection })`.
+    var tabBar: TabBar? = nil
     /// Hybrid: web-storage keys the page's own code writes, mirrored into the
     /// Keychain under another name for native screens (`{"auth_token": "auth.token"}`).
     var shareStorage: [String: String]? = nil
@@ -1733,6 +1854,15 @@ struct CraftConfig: Codable {
         var selectedIconPulse: Bool? = nil
     }
 
+    struct TabBar: Codable {
+        var selection: TabSelection? = nil
+    }
+
+    struct TabSelection: Codable {
+        var cornerRadius: Double? = nil
+        var color: String? = nil
+    }
+
     struct BackgroundRefresh: Codable {
         var enabled: Bool = false
         /// The BGTaskScheduler identifier; `<bundleId>.refresh` if unset.
@@ -2535,6 +2665,18 @@ struct CraftWebView: UIViewRepresentable {
                 resolveCallback(callbackId, result: CraftSymbols.image(named: body["name"] as? String ?? "", options: body) ?? NSNull())
             case "statusBarSetStyle":
                 resolveCallback(callbackId, result: CraftStatusBar.setStyle(body["style"] as? String ?? "default"))
+            case "setAppearance":
+                guard let appearance = body["appearance"] as? String else {
+                    rejectCallback(callbackId, error: "setAppearance needs light, dark or system", code: "INVALID_ARGUMENT")
+                    return
+                }
+                guard CraftInterfaceStyleController.set(appearance) else {
+                    rejectCallback(callbackId, error: "setAppearance needs light, dark or system", code: "INVALID_ARGUMENT")
+                    return
+                }
+                resolveCallback(callbackId, result: true)
+            case "getAppearance":
+                resolveCallback(callbackId, result: CraftInterfaceStyleController.currentName())
             case "chromeSetUnderPageColor":
                 // What shows past the page's edges when it rubber-bands.
                 if #available(iOS 15.0, *), let webView, let css = body["color"] as? String, let color = UIColor(css: css) {
@@ -3116,6 +3258,22 @@ struct CraftWebView: UIViewRepresentable {
                 } else {
                     rejectCallback(callbackId, error: "HealthKit is disabled", code: "CAPABILITY_DISABLED")
                 }
+            // Glucose, insulin and carbs, one sample at a time (CraftHealth.swift).
+            case "getHealthSamples":
+                if config.enableHealthKit {
+                    if let dataType = body["type"] as? String {
+                        CraftHealth.shared.getSamples(
+                            type: dataType,
+                            startDate: body["startDate"] as? Double,
+                            endDate: body["endDate"] as? Double,
+                            limit: body["limit"] as? Int
+                        ) { [weak self] in self?.answer(callbackId, $0) }
+                    } else {
+                        rejectCallback(callbackId, error: "getHealthSamples was called without a type", code: "INVALID_ARGUMENT")
+                    }
+                } else {
+                    rejectCallback(callbackId, error: "HealthKit is disabled", code: "CAPABILITY_DISABLED")
+                }
             case "getHealthSleepIntervals":
                 if config.enableHealthKit {
                     getHealthSleepIntervals(
@@ -5580,6 +5738,14 @@ struct CraftWebView: UIViewRepresentable {
                     getInfo: function() { return craft.getDeviceInfo(); },
                     getCapabilities: function() { return Promise.resolve(Object.assign({}, craft.capabilities)); }
                 };
+                craft.app = Object.assign(craft.app || {}, {
+                    setAppearance: function(appearance) {
+                        return craft._invoke('setAppearance', {appearance: appearance});
+                    },
+                    getAppearance: function() {
+                        return craft._invoke('getAppearance', {});
+                    }
+                });
                 // Feedback, as on Android and the web, where there is no
                 // motor to fire: an app that left enableHaptics off gets
                 // nothing played and a settled promise, so `await
@@ -5749,6 +5915,10 @@ struct CraftWebView: UIViewRepresentable {
                         options = options || {};
                         return craft._invoke('getHealthHeartRateSamples', {startDate: options.startDate, endDate: options.endDate, limit: options.limit});
                     },
+                    getSamples: function(type, options) {
+                        options = options || {};
+                        return craft._invoke('getHealthSamples', {type: type, startDate: options.startDate, endDate: options.endDate, limit: options.limit});
+                    },
                     getSleepIntervals: function(options) {
                         options = options || {};
                         return craft._invoke('getHealthSleepIntervals', {startDate: options.startDate, endDate: options.endDate});

package/dist/ios/templates/CraftHealth.swift

@@ -106,6 +106,9 @@ final class CraftHealth {
             getDailyStatistics(type: type, startDate: options(1)["startDate"] as? Double, endDate: options(1)["endDate"] as? Double, completion: completion)
         case "getHeartRateSamples":
             getHeartRateSamples(startDate: options(0)["startDate"] as? Double, endDate: options(0)["endDate"] as? Double, limit: options(0)["limit"] as? Int, completion: completion)
+        case "getSamples":
+            guard let type = args.first as? String else { return completion(.failure(CraftHealthError(message: "getSamples needs a type", code: "INVALID_ARGUMENT"))) }
+            getSamples(type: type, startDate: options(1)["startDate"] as? Double, endDate: options(1)["endDate"] as? Double, limit: options(1)["limit"] as? Int, completion: completion)
         case "getSleepIntervals":
             getSleepIntervals(startDate: options(0)["startDate"] as? Double, endDate: options(0)["endDate"] as? Double, completion: completion)
         case "saveMindfulSession":
@@ -196,6 +199,12 @@ final class CraftHealth {
                     readTypes.insert(mindfulType)
                     shareTypes.insert(mindfulType)
                 }
+            case "bloodGlucose", "insulinDelivery":
+                // A CGM, meter, pump or closed loop's own writes: read
+                // only, never written back, so the sheet only asks to read.
+                if let diabetesType = Self.healthQuantity(type)?.type {
+                    readTypes.insert(diabetesType)
+                }
             case "dietaryEnergy", "dietaryProtein", "dietaryCarbohydrates", "dietaryFat":
                 // What a food log (MyFitnessPal, Lose It!, Cronometer...)
                 // writes to Apple Health. Request the write grant too unless
@@ -404,6 +413,8 @@ final class CraftHealth {
         case "dietaryProtein": return (HKQuantityType.quantityType(forIdentifier: .dietaryProtein), .gram(), .cumulativeSum)
         case "dietaryCarbohydrates": return (HKQuantityType.quantityType(forIdentifier: .dietaryCarbohydrates), .gram(), .cumulativeSum)
         case "dietaryFat": return (HKQuantityType.quantityType(forIdentifier: .dietaryFatTotal), .gram(), .cumulativeSum)
+        case "bloodGlucose": return (HKQuantityType.quantityType(forIdentifier: .bloodGlucose), HKUnit(from: "mg/dL"), .discreteAverage)
+        case "insulinDelivery": return (HKQuantityType.quantityType(forIdentifier: .insulinDelivery), .internationalUnit(), .cumulativeSum)
         default: return nil
         }
     }
@@ -613,6 +624,71 @@ final class CraftHealth {
         healthStore.execute(query)
     }
 
+    /// The types `getSamples` reads, and the unit each answers in.
+    private static let sampleUnits: [String: String] = ["bloodGlucose": "mg/dL", "insulinDelivery": "IU", "dietaryCarbohydrates": "g"]
+
+    /// Every glucose reading, insulin dose or carb entry between two
+    /// instants, oldest first, as the writing app saved it: its UUID (so a
+    /// sync stores it once), value, source and device, plus what a diabetes
+    /// app needs to tell readings and doses apart: an insulin dose's reason
+    /// (basal or bolus) and a glucose reading's meal time.
+    func getSamples(type: String, startDate: Double?, endDate: Double?, limit: Int?, completion rawCompletion: @escaping Completion) {
+        let completion = completeOnMain(rawCompletion)
+        guard let healthStore = healthStore else {
+            completion(.failure(CraftHealthError(message: "HealthKit not available")))
+            return
+        }
+        guard let unitName = Self.sampleUnits[type], let spec = Self.healthQuantity(type), let sampleType = spec.type else {
+            completion(.failure(CraftHealthError(message: "getSamples reads bloodGlucose, insulinDelivery or dietaryCarbohydrates", code: "INVALID_ARGUMENT")))
+            return
+        }
+
+        let end = endDate.map { Date(timeIntervalSince1970: $0 / 1000) } ?? Date()
+        let start = startDate.map { Date(timeIntervalSince1970: $0 / 1000) } ?? Calendar.current.date(byAdding: .day, value: -7, to: end)!
+        let predicate = HKQuery.predicateForSamples(withStart: start, end: end, options: [])
+        let oldestFirst = NSSortDescriptor(key: HKSampleSortIdentifierStartDate, ascending: true)
+        let cap = max(1, min(limit ?? 10_000, 50_000))
+        let ownBundle = Bundle.main.bundleIdentifier
+
+        let query = HKSampleQuery(sampleType: sampleType, predicate: predicate, limit: cap, sortDescriptors: [oldestFirst]) { _, samples, error in
+            if let error = error, (error as? HKError)?.code != .errorNoData {
+                completion(.failure(CraftHealthError(message: error.localizedDescription)))
+                return
+            }
+            let rows: [[String: Any]] = (samples as? [HKQuantitySample] ?? []).map { sample in
+                let source = sample.sourceRevision.source
+                var item: [String: Any] = [
+                    "id": sample.uuid.uuidString,
+                    "value": sample.quantity.doubleValue(for: spec.unit),
+                    "unit": unitName,
+                    "startDate": sample.startDate.timeIntervalSince1970 * 1000,
+                    "endDate": sample.endDate.timeIntervalSince1970 * 1000,
+                    "sourceName": source.name,
+                    "sourceBundleId": source.bundleIdentifier,
+                    "ownApp": ownBundle != nil && source.bundleIdentifier == ownBundle,
+                ]
+                if let device = sample.device?.name { item["deviceName"] = device }
+                if let reason = sample.metadata?[HKMetadataKeyInsulinDeliveryReason] as? NSNumber {
+                    switch HKInsulinDeliveryReason(rawValue: reason.intValue) {
+                    case .basal: item["insulinReason"] = "basal"
+                    case .bolus: item["insulinReason"] = "bolus"
+                    default: break
+                    }
+                }
+                if let meal = sample.metadata?[HKMetadataKeyBloodGlucoseMealTime] as? NSNumber {
+                    switch HKBloodGlucoseMealTime(rawValue: meal.intValue) {
+                    case .preprandial: item["mealTime"] = "beforeMeal"
+                    case .postprandial: item["mealTime"] = "afterMeal"
+                    default: break
+                    }
+                }
+                return item
+            }
+            completion(.success(rows))
+        }
+        healthStore.execute(query)
+    }
+
     /// One heart-rate sample as a page sees it, from a read or the stream
     /// alike: bpm, when, the app and device that wrote it, a series' count,
     /// lowest and highest, and what the wearer was doing when the watch says.

package/dist/ios/templates/CraftHybrid.swift

@@ -380,7 +380,7 @@ final class CraftHybrid: NSObject {
         }
         startsNative = isEnabled && routes.match(startPath) != nil
         // The splash waits for a page; an all-native app's first screen draws itself.
-        CraftChrome.shared.configure(tabs: config.tabs ?? [], selected: tabIds(from: config.tabs ?? []).isEmpty ? nil : CraftHybridRoutes.tab(owning: startPath, among: tabIds(from: config.tabs ?? [])), splash: hasWeb && !startsNative)
+        CraftChrome.shared.configure(tabs: config.tabs ?? [], selected: tabIds(from: config.tabs ?? []).isEmpty ? nil : CraftHybridRoutes.tab(owning: startPath, among: tabIds(from: config.tabs ?? [])), splash: hasWeb && !startsNative, appearance: config.tabBar)
 
         let script = config.nativeApp.flatMap { $0.isEmpty ? nil : $0 }
         appScriptRoute = script != nil && Self.hasBundle && (isEnabled || !hasWeb) ? script : nil

package/dist/ios/templates/CraftNativeScreen.swift

@@ -2983,7 +2983,10 @@ private class CraftNativeFlowView: UIStackView {
             // The screen reports onLayout from its own layout pass, which a
             // change deep in a scroll view's content never runs: a view that
             // went from 240 to 180 wide kept saying 240.
-            if moved { craftScreenController?.scheduleLayoutEvents() }
+            if moved {
+                craftScreenController?.scheduleLayoutEvents()
+                craftScreenController?.scheduleKeyboardInsets()
+            }
         }
         for (child, frame) in result.frames {
             var viewportFrame = frame
@@ -5112,6 +5115,11 @@ private final class CraftNativeTextView: UITextView {
             isScrollEnabled = overflows
             if overflows, isFirstResponder { scrollRangeToVisible(selectedRange) }
         }
+        // Showing all its text, it has nothing to scroll. An offset left from
+        // UIKit keeping the caret in view while the view was a layout short
+        // of its text moved every line down inside it, and the caret of a
+        // growing comment sat below the part of the screen it was kept in.
+        if !isScrollEnabled, contentOffset != .zero { contentOffset = .zero }
         let inset = textContainerInset
         let padding = textContainer.lineFragmentPadding
         placeholderLabel.frame = CGRect(
@@ -5492,6 +5500,7 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
     private var keyboardSafeAreaInset: CGFloat = 0
     /// Where the keyboard is on the screen while it is up, in screen coordinates.
     private var keyboardScreenFrame: CGRect?
+    private var keyboardInsetsScheduled = false
     /// The hybrid shell (CraftHybrid.swift), when this screen is one of a web
     /// app's native screens: told of the first frame, of a first frame that
     /// could not be drawn, and of `craft.navigation.open(path)`.
@@ -5536,6 +5545,7 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
 
     override func viewDidLoad() {
         super.viewDidLoad()
+        CraftInterfaceStyleController.apply(to: self, config: config)
         navigationItem.title = routeName ?? config.appName
         view.backgroundColor = config.resolvedBackgroundColor
         rootStack.axis = .vertical
@@ -5802,6 +5812,7 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
         positionModals()
         emitLayoutEvents()
         sendViewportIfChanged()
+        scheduleKeyboardInsets()
     }
 
     /// The width the bundle last heard, so a layout pass at the same size says nothing.
@@ -6240,6 +6251,18 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
         let secureGet: @convention(block) (String) -> String? = { key in
             config.enableSecureStorage ? CraftNativeActions.webSecureValue(forKey: key) : nil
         }
+        let setAppearance: @convention(block) (String) -> Bool = { value in
+            if Thread.isMainThread { return CraftInterfaceStyleController.set(value) }
+            var accepted = false
+            DispatchQueue.main.sync { accepted = CraftInterfaceStyleController.set(value) }
+            return accepted
+        }
+        let getAppearance: @convention(block) () -> String = {
+            if Thread.isMainThread { return CraftInterfaceStyleController.currentName() }
+            var value = "light"
+            DispatchQueue.main.sync { value = CraftInterfaceStyleController.currentName() }
+            return value
+        }
         let setOptions: @convention(block) (String) -> Void = { [weak self] json in
             guard let data = json.data(using: .utf8),
                   let options = try? JSONSerialization.jsonObject(with: data) as? [String: Any] else { return }
@@ -6252,6 +6275,8 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
         jsContext.setObject(snapshotSet, forKeyedSubscript: "craftNativeSnapshotSet" as NSString)
         jsContext.setObject(snapshotClear, forKeyedSubscript: "craftNativeSnapshotClear" as NSString)
         jsContext.setObject(secureGet, forKeyedSubscript: "craftNativeSecureGet" as NSString)
+        jsContext.setObject(setAppearance, forKeyedSubscript: "craftNativeSetAppearance" as NSString)
+        jsContext.setObject(getAppearance, forKeyedSubscript: "craftNativeGetAppearance" as NSString)
         jsContext.setObject(setOptions, forKeyedSubscript: "craftNativeSetOptions" as NSString)
         // Older native bundles call the page-shaped `craft.dialog` API
         // directly. Keep that API backed by the same capability protocol as
@@ -6494,6 +6519,19 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
                         return value === undefined ? null : value;
                     }
                 });
+                keep('app', {
+                    setAppearance: function(value) {
+                        value = String(value);
+                        if (value !== 'light' && value !== 'dark' && value !== 'system') {
+                            return Promise.reject(new TypeError('craft.app.setAppearance needs light, dark or system'));
+                        }
+                        if (!craftNativeSetAppearance(value)) {
+                            return Promise.reject(new Error('craft.app.setAppearance was rejected'));
+                        }
+                        return Promise.resolve();
+                    },
+                    getAppearance: function() { return Promise.resolve(craftNativeGetAppearance()); }
+                });
                 // The signed-in account (CraftSession): the token under
                 // `sessionTokenKey`, and each change of it, which the host
                 // reports through `__craftSessionChanged` after the Keychain
@@ -7148,6 +7186,22 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
         }
     }
 
+    /// A layout moved a view while the keyboard is up: once that pass is
+    /// over, each scroll view's keyboard inset is measured again where the
+    /// scroll view now ends. Measured only when the keyboard moved, a form
+    /// that grew down under the keyboard (a footer below it shrank, a
+    /// banner above it went away) kept the inset of where it used to end,
+    /// and its last lines stayed under the keyboard.
+    fileprivate func scheduleKeyboardInsets() {
+        guard keyboardScreenFrame != nil, !keyboardInsetsScheduled else { return }
+        keyboardInsetsScheduled = true
+        DispatchQueue.main.async { [weak self] in
+            guard let self else { return }
+            self.keyboardInsetsScheduled = false
+            if self.keyboardScreenFrame != nil { self.insetScrollViewsForKeyboard() }
+        }
+    }
+
     /// The focused field, scrolled into the part of its scroll view the
     /// keyboard leaves, with a little room around it.
     func scrollFocusedInputIntoView(animated: Bool) {
@@ -7159,6 +7213,8 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
     /// Internal for XCTest.
     func scrollIntoView(_ input: UIView, animated: Bool) {
         guard let scroll = enclosingVerticalScroll(of: input) else { return }
+        // Measured against the keyboard where the scroll view is now.
+        if keyboardScreenFrame != nil { insetScrollViewsForKeyboard() }
         var rect = input.convert(input.bounds, to: scroll).insetBy(dx: 0, dy: -16)
         // A field taller than the part the keyboard leaves (a long comment
         // with no max height) shows its caret rather than its top: scrolled
@@ -9951,6 +10007,9 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
             textView.invalidateIntrinsicContentSize()
             CraftNativeFlexLayout.invalidateAncestors(of: textView)
             self.view.layoutIfNeeded()
+            // That layout can move the scroll view: its keyboard inset is
+            // measured where it now ends before the caret is.
+            if self.keyboardScreenFrame != nil { self.insetScrollViewsForKeyboard() }
             guard let scroll = self.enclosingVerticalScroll(of: textView),
                   let rect = self.caretRect(of: textView, in: scroll) else { return }
             let visible = scroll.bounds.inset(by: scroll.adjustedContentInset)

package/dist/ios/templates/CraftWatchApp.swift.template

@@ -117,6 +117,10 @@ final class CraftWatchSession: NSObject, ObservableObject {
     }
 
     private func apply(_ payload: [String: Any]) {
+        if let incomingVersion = payload["stateVersion"] as? Int {
+            guard incomingVersion >= stateVersion else { return }
+            stateVersion = incomingVersion
+        }
         if let plan = payload["plan"] as? [String: Any], payload["type"] as? String == "planned-session" {
             plannedSession = plan
             status = "Plan ready"

package/dist/mobile.js

@@ -1715,6 +1715,12 @@ var health = {
       throw new Error("Reading heart-rate samples is unavailable");
     return craft.health.getHeartRateSamples(options);
   },
+  async getSamples(type, options = {}) {
+    const craft = getCraftRoot();
+    if (!craft?.health?.getSamples)
+      throw new Error("Reading health samples is unavailable");
+    return craft.health.getSamples(type, options);
+  },
   async getSleepIntervals(options = {}) {
     const craft = getCraftRoot();
     if (!craft?.health?.getSleepIntervals)

package/dist/types.d.ts

@@ -569,6 +569,17 @@ export interface AppConfig {
  * Craft System Tray API (available as window.craft.tray in WebView)
  */
 export interface CraftTrayAPI {
+    /** Read the rendered macOS status item, including its decoded image. */
+    getState(): Promise<{
+        title: string;
+        tooltip: string;
+        visible: boolean;
+        hasIcon: boolean;
+        template: boolean;
+        imageWidth: number;
+        imageHeight: number;
+        imagePosition: number;
+    }>;
     /** SF Symbol name, image path, or base64 image data URL. */
     setIcon(icon: string): Promise<void>;
     /**
@@ -649,6 +660,10 @@ export interface CraftAppAPI {
      * Get application information
      */
     getInfo(): Promise<AppInfo>;
+    /** Pin every native surface to Light, Dark, or the system setting. */
+    setAppearance(appearance: 'light' | 'dark' | 'system'): Promise<void>;
+    /** Read the app's effective Light/Dark appearance. */
+    getAppearance(): Promise<'light' | 'dark'>;
 }
 /**
  * Tray click event details

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "craft-native",
-  "version": "0.0.290",
+  "version": "0.0.296",
   "type": "module",
   "description": "Build desktop apps with web languages - TypeScript SDK for Craft",
   "author": "Chris Breuer <chris@stacksjs.org>",