craft-native 0.0.160 → 0.0.161

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

@@ -298,6 +298,43 @@ object CraftNative {
         margins: FloatArray,
         flags: FloatArray,
     ): FloatArray?
+    private external fun nativeGridAligned(
+        availableWidth: Float,
+        availableHeight: Float,
+        columns: Int,
+        columnGap: Float,
+        rowGap: Float,
+        alignContent: Int,
+        intrinsicWidth: FloatArray,
+        intrinsicHeight: FloatArray,
+        explicitWidth: FloatArray,
+        explicitHeight: FloatArray,
+        minWidth: FloatArray,
+        maxWidth: FloatArray,
+        minHeight: FloatArray,
+        maxHeight: FloatArray,
+        margins: FloatArray,
+        flags: FloatArray,
+    ): FloatArray?
+    private external fun nativeGridAutoRowsAligned(
+        availableWidth: Float,
+        availableHeight: Float,
+        columns: Int,
+        columnGap: Float,
+        rowGap: Float,
+        alignContent: Int,
+        autoRowHeight: Float,
+        intrinsicWidth: FloatArray,
+        intrinsicHeight: FloatArray,
+        explicitWidth: FloatArray,
+        explicitHeight: FloatArray,
+        minWidth: FloatArray,
+        maxWidth: FloatArray,
+        minHeight: FloatArray,
+        maxHeight: FloatArray,
+        margins: FloatArray,
+        flags: FloatArray,
+    ): FloatArray?
     private external fun nativeClipboardRead(activity: Activity): String?
     private external fun nativeClipboardWrite(activity: Activity, text: String): Boolean
     private external fun nativeOpenUrl(activity: Activity, url: String): Boolean
@@ -532,13 +569,14 @@ object CraftNative {
         margins: FloatArray,
         flags: FloatArray,
         autoRowHeight: Float? = null,
+        alignContent: Int = 0,
     ): FloatArray? {
         if (!isAvailable) return null
         return try {
             if (autoRowHeight != null) {
-                nativeGridAutoRows(availableWidth, availableHeight, columns, columnGap, rowGap, autoRowHeight, intrinsicWidth, intrinsicHeight, explicitWidth, explicitHeight, minWidth, maxWidth, minHeight, maxHeight, margins, flags)
+                nativeGridAutoRowsAligned(availableWidth, availableHeight, columns, columnGap, rowGap, alignContent, autoRowHeight, intrinsicWidth, intrinsicHeight, explicitWidth, explicitHeight, minWidth, maxWidth, minHeight, maxHeight, margins, flags)
             } else {
-                nativeGrid(availableWidth, availableHeight, columns, columnGap, rowGap, intrinsicWidth, intrinsicHeight, explicitWidth, explicitHeight, minWidth, maxWidth, minHeight, maxHeight, margins, flags)
+                nativeGridAligned(availableWidth, availableHeight, columns, columnGap, rowGap, alignContent, intrinsicWidth, intrinsicHeight, explicitWidth, explicitHeight, minWidth, maxWidth, minHeight, maxHeight, margins, flags)
             }
                 ?.takeIf { it.size >= intrinsicWidth.size * 4 && it.all { value -> value.isFinite() } }
         } catch (e: UnsatisfiedLinkError) {

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

@@ -303,7 +303,8 @@ internal class CraftNativeCapabilities(
         return FileResult.Multipart(body.toByteArray(), boundary)
     }
 
-    private fun files(requestToken: String, method: String, args: JSONArray): CraftNativeCapabilityResult = when (method) {
+    private fun files(requestToken: String, method: String, args: JSONArray): CraftNativeCapabilityResult {
+        return when (method) {
         "write" -> {
             val name = args.optString(0).trim()
             if (name.isBlank()) return failure("INVALID_ARGUMENT", "files.write needs a file name")
@@ -322,7 +323,8 @@ internal class CraftNativeCapabilities(
             success(file.delete())
         }
         "download" -> download(requestToken, args)
-        else -> failure("UNKNOWN_ACTION", "Unsupported Files method")
+            else -> failure("UNKNOWN_ACTION", "Unsupported Files method")
+        }
     }
 
     private fun download(requestToken: String, args: JSONArray): CraftNativeCapabilityResult {

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

@@ -115,6 +115,7 @@ private data class CraftNativeLength(
 private data class CraftNativeLayoutStyle(
     val width: CraftNativeLength? = null,
     val height: CraftNativeLength? = null,
+    val aspectRatio: Double? = null,
     val minWidth: CraftNativeLength? = null,
     val maxWidth: CraftNativeLength? = null,
     val minHeight: CraftNativeLength? = null,
@@ -143,6 +144,7 @@ private data class CraftNativeLayoutStyle(
             val flex = decimal("flex")
             return CraftNativeLayoutStyle(
                 width = length("width"), height = length("height"),
+                aspectRatio = decimal("aspectRatio")?.takeIf { it.isFinite() && it > 0.0 },
                 minWidth = length("minWidth"), maxWidth = length("maxWidth"),
                 minHeight = length("minHeight"), maxHeight = length("maxHeight"),
                 position = raw.opt("position")
@@ -583,7 +585,8 @@ private class CraftNativeFlexLayout(context: Context) : LinearLayout(context) {
         // The STX style is authoritative. A reused View may still carry a
         // previous fixed LayoutParams width after a reactive width is removed;
         // using that value here prevents intrinsic sizing from being restored.
-        val explicit = style.width?.resolve(base) ?: flexBasis
+        val authored = style.width?.resolve(base)
+        val explicit = authored ?: style.aspectRatio?.let { ratio -> style.height?.resolve(base)?.times(ratio)?.roundToInt() } ?: flexBasis
         if (explicit != null) {
             child.measure(
                 View.MeasureSpec.makeMeasureSpec(explicit, View.MeasureSpec.EXACTLY),
@@ -613,7 +616,8 @@ private class CraftNativeFlexLayout(context: Context) : LinearLayout(context) {
         val flexBasis = if (orientation == VERTICAL) style.flexBasis?.resolve(base) else null
         // Match width measurement: do not let stale native LayoutParams keep
         // a removed reactive height fixed.
-        val explicit = style.height?.resolve(base) ?: flexBasis
+        val authored = style.height?.resolve(base)
+        val explicit = authored ?: style.aspectRatio?.let { ratio -> style.width?.resolve(base)?.div(ratio)?.roundToInt() } ?: flexBasis
         val target = explicit ?: base
         val spec = if (explicit != null) View.MeasureSpec.makeMeasureSpec(target, View.MeasureSpec.EXACTLY)
         else View.MeasureSpec.makeMeasureSpec(base, View.MeasureSpec.AT_MOST)
@@ -772,6 +776,7 @@ private class CraftNativeFlexLayout(context: Context) : LinearLayout(context) {
                     listOf(if (align == "stretch") 1f else 0f, if (align == "center") 1f else if (align == "flex-end") 2f else 0f)
                 }.toFloatArray(),
                 gridAutoRows?.resolve(contentHeight)?.toFloat(),
+                alignContentCode(),
             )
             if (sharedFrames != null) {
                 for ((index, entry) in flow.withIndex()) {
@@ -783,9 +788,26 @@ private class CraftNativeFlexLayout(context: Context) : LinearLayout(context) {
                     entry.view.layout(x, y, x + childWidth, y + childHeight)
                 }
             } else {
-                var rowTop = paddingTop
+                val totalRows = layout.rowHeights.sum()
+                val rowGaps = max(0, layout.rowHeights.size - 1) * rowGap
+                val freeRows = max(0, contentHeight - totalRows - rowGaps)
+                val rowCount = max(1, layout.rowHeights.size)
+                var rowLeading = 0
+                var rowBetween = rowGap
+                var rowExtra = 0
+                when (alignContentCode()) {
+                    1 -> rowLeading = freeRows / 2
+                    2 -> rowLeading = freeRows
+                    3 -> if (rowCount > 1) rowBetween += freeRows / (rowCount - 1)
+                    4 -> {
+                        rowLeading = freeRows / (rowCount * 2)
+                        rowBetween += freeRows / rowCount
+                    }
+                    5 -> rowExtra = freeRows / rowCount
+                }
+                var rowTop = paddingTop + rowLeading
                 for ((rowIndex, row) in layout.rows.withIndex()) {
-                    val rowHeight = layout.rowHeights[rowIndex]
+                    val rowHeight = layout.rowHeights[rowIndex] + rowExtra
                     for ((column, entry) in row.withIndex()) {
                         val align = entry.style.alignSelf ?: alignItems
                         val lp = entry.view.layoutParams as? MarginLayoutParams
@@ -809,7 +831,7 @@ private class CraftNativeFlexLayout(context: Context) : LinearLayout(context) {
                         }
                         entry.view.layout(x, y, x + childWidth, y + childHeight)
                     }
-                    rowTop += rowHeight + rowGap
+                    rowTop += rowHeight + rowBetween
                 }
             }
             for (entry in layout.absolute) {
@@ -2803,7 +2825,7 @@ class MainActivity : AppCompatActivity() {
             "Svg" -> (previous as? CraftNativeSvgView ?: CraftNativeSvgView(this)).apply {
                 drawing = node
             }
-            "ScrollView" -> (previous as? CraftNativeScrollView ?: CraftNativeScrollView(this)).apply {
+            "ScrollView", "SectionList" -> (previous as? CraftNativeScrollView ?: CraftNativeScrollView(this)).apply {
                 val horizontal = props.optBoolean("horizontal", false) || style.optString("flexDirection") in setOf("row", "row-reverse")
                 setHorizontal(horizontal)
                 setNativeNestedScrollingEnabled(true)
@@ -3064,6 +3086,7 @@ class MainActivity : AppCompatActivity() {
         "video" -> "Video"
         "icon" -> "Icon"
         "scrollview" -> "ScrollView"
+        "sectionlist" -> "SectionList"
         "flatlist" -> "FlatList"
         "svg" -> "Svg"
         "touchableopacity" -> "TouchableOpacity"
@@ -3477,7 +3500,9 @@ class MainActivity : AppCompatActivity() {
             else -> null
         }
         view.tooltipText = props.optString("accessibilityHint").takeIf { it.isNotBlank() }
-        val role = props.optString("accessibilityRole").ifBlank { type.lowercase() }
+        val role = props.optString("accessibilityRole").ifBlank {
+            if (type == "Icon") "image" else type.lowercase()
+        }
         val state = props.optJSONObject("accessibilityState")
         val disabled = props.optBoolean("disabled", false) || state?.optBoolean("disabled", false) == true
         if (type !in setOf("Button", "Link", "Checkbox", "TextInput", "Picker", "DatePicker", "Modal", "Switch", "Slider", "ActivityIndicator")) {

package/dist/api/mobile.d.ts

@@ -1240,9 +1240,11 @@ export declare const pushNotifications: {
 };
 export type HealthDataType = 'steps' | 'heartRate' | 'activeEnergy' | 'distance' | 'workouts' | 'restingHeartRate' | 'heartRateVariability' | 'bodyMass' | 'sleep'
 /** Food logged by any app, per day: kcal eaten, then grams of protein, carbohydrate and fat. Read only. */
- | 'dietaryEnergy' | 'dietaryProtein' | 'dietaryCarbohydrates' | 'dietaryFat';
+ | 'dietaryEnergy' | 'dietaryProtein' | 'dietaryCarbohydrates' | 'dietaryFat'
+/** Mindful minutes (meditation, breathing): read with getMindfulSessions, written with saveMindfulSession. */
+ | 'mindful';
 /** The types with one value per day. `sleep` is hours asleep, counted on the day you woke. */
-export type HealthDailyType = Exclude<HealthDataType, 'workouts'>;
+export type HealthDailyType = Exclude<HealthDataType, 'workouts' | 'mindful'>;
 export interface HealthAuthorizationOptions {
     /** `false` asks to read only. Default: also allowed to save workouts. */
     write?: boolean;
@@ -1350,8 +1352,49 @@ export interface HealthSleepInterval {
     sourceName: string;
     deviceName?: string;
 }
-/** The health reads a host may or may not have, depending on the app build it runs in. */
-export type HealthReadMethod = 'getWorkouts' | 'getDailyStatistics' | 'getHeartRateSamples' | 'getSleepIntervals';
+/** A meditation or breathing session to record as mindful minutes. */
+export interface HealthMindfulSession {
+    /**
+     * The app's own id for the session (up to 128 characters), kept as the
+     * sample's external UUID. Saving the same id again keeps the first sample.
+     */
+    id: string;
+    /** Epoch milliseconds. */
+    startDate: number;
+    /** Epoch milliseconds, after `startDate` and at most a day later. */
+    endDate: number;
+}
+export interface HealthMindfulSessionResult {
+    /** HealthKit's UUID for the sample. */
+    id: string;
+    /** The id it was saved with. */
+    externalId: string;
+    /** True when this id was saved before and that sample was kept. */
+    existing: boolean;
+}
+export interface HealthMindfulSessionQuery extends HealthSampleQuery {
+    /** At most this many, oldest first. Defaults to 1000, capped at 5000. Start defaults to 30 days ago. */
+    limit?: number;
+}
+/** A mindful session in Apple Health, from any app that writes them. */
+export interface HealthMindfulSample {
+    /** HealthKit's UUID. */
+    id: string;
+    /** Epoch milliseconds. */
+    startDate: number;
+    /** Epoch milliseconds. */
+    endDate: number;
+    durationSeconds: number;
+    sourceName: string;
+    sourceBundleId: string;
+    /** True when this app wrote it. */
+    ownApp: boolean;
+    /** The id the writing app saved it with, when it gave one. */
+    externalId?: string;
+    deviceName?: 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' | 'saveMindfulSession' | 'getMindfulSessions';
 export declare const health: {
     /**
      * Whether this app build answers `method`. An app installed before a read
@@ -1374,6 +1417,14 @@ export declare const health: {
     getHeartRateSamples(options?: HealthHeartRateQuery): Promise<HealthHeartRateSample[]>;
     /** Sleep between two instants, oldest first: time in bed and each asleep or awake stage. iOS only for now. */
     getSleepIntervals(options?: HealthSampleQuery): Promise<HealthSleepInterval[]>;
+    /**
+     * Record a meditation or breathing session as mindful minutes. Needs the
+     * `mindful` grant with writing allowed. Saving the same `id` again keeps
+     * the first sample. iOS only for now.
+     */
+    saveMindfulSession(session: HealthMindfulSession): Promise<HealthMindfulSessionResult>;
+    /** Mindful sessions between two instants, oldest first, each marked `ownApp` when this app wrote it. iOS only for now. */
+    getMindfulSessions(options?: HealthMindfulSessionQuery): Promise<HealthMindfulSample[]>;
 };
 export interface LiveActivityState {
     status?: string;

package/dist/cli.js

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

package/dist/index.cjs

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

package/dist/index.js

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

package/dist/ios/templates/CraftApp.swift

@@ -2548,6 +2548,22 @@ struct CraftWebView: UIViewRepresentable {
                 } else {
                     rejectCallback(callbackId, error: "HealthKit is disabled", code: "CAPABILITY_DISABLED")
                 }
+            case "saveHealthMindfulSession":
+                if config.enableHealthKit {
+                    CraftHealth.shared.saveMindfulSession(body: body) { [weak self] in self?.answer(callbackId, $0) }
+                } else {
+                    rejectCallback(callbackId, error: "HealthKit is disabled", code: "CAPABILITY_DISABLED")
+                }
+            case "getHealthMindfulSessions":
+                if config.enableHealthKit {
+                    CraftHealth.shared.getMindfulSessions(
+                        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: "HealthKit is disabled", code: "CAPABILITY_DISABLED")
+                }
 
             // MARK: - Live Activities
             case "startLiveActivity":
@@ -5056,6 +5072,14 @@ struct CraftWebView: UIViewRepresentable {
                     getSleepIntervals: function(options) {
                         options = options || {};
                         return craft._invoke('getHealthSleepIntervals', {startDate: options.startDate, endDate: options.endDate});
+                    },
+                    saveMindfulSession: function(session) {
+                        session = session || {};
+                        return craft._invoke('saveHealthMindfulSession', {id: session.id, startDate: session.startDate, endDate: session.endDate});
+                    },
+                    getMindfulSessions: function(options) {
+                        options = options || {};
+                        return craft._invoke('getHealthMindfulSessions', {startDate: options.startDate, endDate: options.endDate, limit: options.limit});
                     }
                 };
                 // The Music app's song and transport. Nothing is read until

package/dist/ios/templates/CraftHealth.swift

@@ -43,6 +43,10 @@ final class CraftHealth {
             getHeartRateSamples(startDate: options(0)["startDate"] as? Double, endDate: options(0)["endDate"] as? Double, limit: options(0)["limit"] as? Int, completion: completion)
         case "getSleepIntervals":
             getSleepIntervals(startDate: options(0)["startDate"] as? Double, endDate: options(0)["endDate"] as? Double, completion: completion)
+        case "saveMindfulSession":
+            saveMindfulSession(body: options(0), completion: completion)
+        case "getMindfulSessions":
+            getMindfulSessions(startDate: options(0)["startDate"] as? Double, endDate: options(0)["endDate"] as? Double, limit: options(0)["limit"] as? Int, completion: completion)
         default:
             completion(.failure(CraftHealthError(message: "Unsupported Health method", code: "UNKNOWN_ACTION")))
         }
@@ -106,6 +110,14 @@ final class CraftHealth {
                 if let sleepType = HKObjectType.categoryType(forIdentifier: .sleepAnalysis) {
                     readTypes.insert(sleepType)
                 }
+            case "mindful":
+                // Mindful minutes: a meditation or breathing session. Read
+                // to show them, and (unless read only) written by an app
+                // that times them.
+                if let mindfulType = HKObjectType.categoryType(forIdentifier: .mindfulSession) {
+                    readTypes.insert(mindfulType)
+                    shareTypes.insert(mindfulType)
+                }
             case "dietaryEnergy", "dietaryProtein", "dietaryCarbohydrates", "dietaryFat":
                 // What a food log (MyFitnessPal, Lose It!, Cronometer...)
                 // writes to Apple Health: read only, never written back.
@@ -559,4 +571,104 @@ final class CraftHealth {
         healthStore.execute(query)
     }
 
+    /// Saves a mindful session (Mindful Minutes in the Health app): a
+    /// meditation or breathing session that ran from `startDate` to
+    /// `endDate`, epoch milliseconds. `id` is the app's own id for it, kept
+    /// as the sample's external UUID, so saving the same session twice (a
+    /// retry, a second device) keeps the first sample instead of adding
+    /// another: the answer then says `existing: true`.
+    func saveMindfulSession(body: [String: Any], completion: @escaping Completion) {
+        guard let healthStore = healthStore else {
+            completion(.failure(CraftHealthError(message: "HealthKit not available")))
+            return
+        }
+        guard let mindfulType = HKObjectType.categoryType(forIdentifier: .mindfulSession) else {
+            completion(.failure(CraftHealthError(message: "Mindful sessions are unavailable")))
+            return
+        }
+        guard let id = body["id"] as? String, !id.isEmpty, id.count <= 128,
+              let startValue = body["startDate"] as? Double,
+              let endValue = body["endDate"] as? Double,
+              endValue > startValue,
+              endValue - startValue <= 24 * 3600 * 1000 else {
+            completion(.failure(CraftHealthError(message: "A valid id, startDate and endDate (at most a day apart) are required", code: "INVALID_ARGUMENT")))
+            return
+        }
+
+        let start = Date(timeIntervalSince1970: startValue / 1000)
+        let end = Date(timeIntervalSince1970: endValue / 1000)
+        // Only this app's own samples can be the same session.
+        let predicate = NSCompoundPredicate(andPredicateWithSubpredicates: [
+            HKQuery.predicateForObjects(withMetadataKey: HKMetadataKeyExternalUUID, allowedValues: [id]),
+            HKQuery.predicateForObjects(from: HKSource.default()),
+        ])
+        let lookup = HKSampleQuery(sampleType: mindfulType, predicate: predicate, limit: 1, sortDescriptors: nil) { _, samples, _ in
+            if let kept = samples?.first {
+                completion(.success(["id": kept.uuid.uuidString, "externalId": id, "existing": true]))
+                return
+            }
+            let sample = HKCategorySample(
+                type: mindfulType,
+                value: HKCategoryValue.notApplicable.rawValue,
+                start: start,
+                end: end,
+                metadata: [HKMetadataKeyExternalUUID: id]
+            )
+            healthStore.save(sample) { success, error in
+                if success {
+                    completion(.success(["id": sample.uuid.uuidString, "externalId": id, "existing": false]))
+                } else {
+                    completion(.failure(CraftHealthError(message: error?.localizedDescription ?? "Mindful session could not be saved")))
+                }
+            }
+        }
+        healthStore.execute(lookup)
+    }
+
+    /// Mindful sessions between two instants, oldest first, from every app
+    /// that writes them (the Mindfulness app, Calm, this one). Each says
+    /// whether this app wrote it (`ownApp`) and carries the external id it
+    /// was saved with, so a page can tell its own sessions from the rest.
+    func getMindfulSessions(startDate: Double?, endDate: Double?, limit: Int?, completion: @escaping Completion) {
+        guard let healthStore = healthStore else {
+            completion(.failure(CraftHealthError(message: "HealthKit not available")))
+            return
+        }
+        guard let mindfulType = HKObjectType.categoryType(forIdentifier: .mindfulSession) else {
+            completion(.failure(CraftHealthError(message: "Mindful sessions are unavailable")))
+            return
+        }
+
+        let end = endDate.map { Date(timeIntervalSince1970: $0 / 1000) } ?? Date()
+        let start = startDate.map { Date(timeIntervalSince1970: $0 / 1000) } ?? Calendar.current.date(byAdding: .day, value: -30, to: end)!
+        let predicate = HKQuery.predicateForSamples(withStart: start, end: end, options: [])
+        let oldestFirst = NSSortDescriptor(key: HKSampleSortIdentifierStartDate, ascending: true)
+        let cap = max(1, min(limit ?? 1000, 5000))
+        let ownBundle = Bundle.main.bundleIdentifier
+
+        let query = HKSampleQuery(sampleType: mindfulType, 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 ?? []).map { sample in
+                let source = sample.sourceRevision.source
+                var item: [String: Any] = [
+                    "id": sample.uuid.uuidString,
+                    "startDate": sample.startDate.timeIntervalSince1970 * 1000,
+                    "endDate": sample.endDate.timeIntervalSince1970 * 1000,
+                    "durationSeconds": sample.endDate.timeIntervalSince(sample.startDate),
+                    "sourceName": source.name,
+                    "sourceBundleId": source.bundleIdentifier,
+                    "ownApp": ownBundle != nil && source.bundleIdentifier == ownBundle,
+                ]
+                if let external = sample.metadata?[HKMetadataKeyExternalUUID] as? String { item["externalId"] = external }
+                if let device = sample.device?.name { item["deviceName"] = device }
+                return item
+            }
+            completion(.success(rows))
+        }
+        healthStore.execute(query)
+    }
+
 }

package/dist/ios/templates/CraftNativeScreen.swift

@@ -185,6 +185,12 @@ private enum CraftNativeGridBridge {
     private typealias AutoRowsFunction = @convention(c) (
         Float, Float, UInt32, Float, Float, Float, UnsafeRawPointer, Int, UnsafeMutableRawPointer
     ) -> Int32
+    private typealias AlignedFunction = @convention(c) (
+        Float, Float, UInt32, Float, Float, UInt32, UnsafeRawPointer, Int, UnsafeMutableRawPointer
+    ) -> Int32
+    private typealias AutoRowsAlignedFunction = @convention(c) (
+        Float, Float, UInt32, Float, Float, UInt32, Float, UnsafeRawPointer, Int, UnsafeMutableRawPointer
+    ) -> Int32
 
     private static let function: Function? = {
         guard let symbol = dlsym(UnsafeMutableRawPointer(bitPattern: -2), "craft_native_grid") else { return nil }
@@ -194,6 +200,14 @@ private enum CraftNativeGridBridge {
         guard let symbol = dlsym(UnsafeMutableRawPointer(bitPattern: -2), "craft_native_grid_auto_rows") else { return nil }
         return unsafeBitCast(symbol, to: AutoRowsFunction.self)
     }()
+    private static let alignedFunction: AlignedFunction? = {
+        guard let symbol = dlsym(UnsafeMutableRawPointer(bitPattern: -2), "craft_native_grid_aligned") else { return nil }
+        return unsafeBitCast(symbol, to: AlignedFunction.self)
+    }()
+    private static let autoRowsAlignedFunction: AutoRowsAlignedFunction? = {
+        guard let symbol = dlsym(UnsafeMutableRawPointer(bitPattern: -2), "craft_native_grid_auto_rows_aligned") else { return nil }
+        return unsafeBitCast(symbol, to: AutoRowsAlignedFunction.self)
+    }()
 
     static func frames(
         availableWidth: CGFloat,
@@ -202,7 +216,8 @@ private enum CraftNativeGridBridge {
         columnGap: CGFloat,
         rowGap: CGFloat,
         items: [(intrinsicWidth: CGFloat, intrinsicHeight: CGFloat, explicitWidth: CGFloat?, explicitHeight: CGFloat?, minWidth: CGFloat?, maxWidth: CGFloat?, minHeight: CGFloat?, maxHeight: CGFloat?, marginLeft: CGFloat, marginRight: CGFloat, marginTop: CGFloat, marginBottom: CGFloat, stretch: Bool, alignment: UInt32)],
-        autoRowHeight: CGFloat? = nil
+        autoRowHeight: CGFloat? = nil,
+        alignContent: UInt32 = 0
     ) -> [(x: CGFloat, y: CGFloat, width: CGFloat, height: CGFloat)]? {
         guard !items.isEmpty else { return nil }
         if autoRowHeight != nil, autoRowsFunction == nil { return nil }
@@ -222,8 +237,14 @@ private enum CraftNativeGridBridge {
         let status = input.withUnsafeBufferPointer { inputBuffer in
             output.withUnsafeMutableBufferPointer { outputBuffer in
                 if let autoRowHeight, let autoRowsFunction {
+                    if alignContent != 0, let autoRowsAlignedFunction {
+                        return autoRowsAlignedFunction(Float(availableWidth), Float(availableHeight), UInt32(max(1, columns)), Float(columnGap), Float(rowGap), alignContent, Float(autoRowHeight), UnsafeRawPointer(inputBuffer.baseAddress!), input.count, UnsafeMutableRawPointer(outputBuffer.baseAddress!))
+                    }
                     return autoRowsFunction(Float(availableWidth), Float(availableHeight), UInt32(max(1, columns)), Float(columnGap), Float(rowGap), Float(autoRowHeight), UnsafeRawPointer(inputBuffer.baseAddress!), input.count, UnsafeMutableRawPointer(outputBuffer.baseAddress!))
                 }
+                if alignContent != 0, let alignedFunction {
+                    return alignedFunction(Float(availableWidth), Float(availableHeight), UInt32(max(1, columns)), Float(columnGap), Float(rowGap), alignContent, UnsafeRawPointer(inputBuffer.baseAddress!), input.count, UnsafeMutableRawPointer(outputBuffer.baseAddress!))
+                }
                 guard let function else { return Int32(-1) }
                 return function(Float(availableWidth), Float(availableHeight), UInt32(max(1, columns)), Float(columnGap), Float(rowGap), UnsafeRawPointer(inputBuffer.baseAddress!), input.count, UnsafeMutableRawPointer(outputBuffer.baseAddress!))
             }
@@ -235,6 +256,17 @@ private enum CraftNativeGridBridge {
     }
 }
 
+private func craftNativeAlignContentCode(_ value: String) -> UInt32 {
+    switch value {
+    case "center": return 1
+    case "flex-end": return 2
+    case "space-between": return 3
+    case "space-around": return 4
+    case "stretch": return 5
+    default: return 0
+    }
+}
+
 private final class CraftNativeVideoView: UIView {
     private let playerController = AVPlayerViewController()
     private var player: AVPlayer?
@@ -436,6 +468,7 @@ private enum CraftNativeLength: Equatable {
 private struct CraftNativeLayoutStyle {
     let width: CraftNativeLength?
     let height: CraftNativeLength?
+    let aspectRatio: CGFloat?
     let minWidth: CraftNativeLength?
     let maxWidth: CraftNativeLength?
     let minHeight: CraftNativeLength?
@@ -465,6 +498,8 @@ private struct CraftNativeLayoutStyle {
         func number(_ value: Any?) -> CGFloat? { (value as? NSNumber).map { CGFloat(truncating: $0) } }
         width = CraftNativeLength(raw["width"])
         height = CraftNativeLength(raw["height"])
+        let ratio = number(raw["aspectRatio"])
+        aspectRatio = ratio.flatMap { $0.isFinite && $0 > 0 ? $0 : nil }
         minWidth = CraftNativeLength(raw["minWidth"])
         maxWidth = CraftNativeLength(raw["maxWidth"])
         minHeight = CraftNativeLength(raw["minHeight"])
@@ -870,12 +905,13 @@ private class CraftNativeFlowView: UIStackView {
             let content = CGRect(x: padding.left, y: padding.top, width: max(0, size.width - paddingWidth), height: max(0, size.height - paddingHeight))
             for child in children where child.craftLayoutStyle.position == "absolute" {
                 let style = child.craftLayoutStyle
-                let fixedWidth = style.left != nil && style.right != nil
+                var fixedWidth = style.left != nil && style.right != nil
                     ? max(0, content.width - (style.left ?? 0) - (style.right ?? 0))
                     : style.width?.resolve(content.width)
-                let fixedHeight = style.top != nil && style.bottom != nil
+                var fixedHeight = style.top != nil && style.bottom != nil
                     ? max(0, content.height - (style.top ?? 0) - (style.bottom ?? 0))
                     : style.height?.resolve(content.height)
+                (fixedWidth, fixedHeight) = aspectDimensions(style, width: fixedWidth, height: fixedHeight)
                 let measured = CraftNativeFlexLayout.measure(child, width: fixedWidth, height: fixedHeight, maxWidth: content.width, maxHeight: content.height)
                 let x = style.left ?? (style.right.map { content.width - $0 - measured.width } ?? 0)
                 let y = style.top ?? (style.bottom.map { content.height - $0 - measured.height } ?? 0)
@@ -885,6 +921,21 @@ private class CraftNativeFlowView: UIStackView {
         return (size, frames)
     }
 
+    /// Resolves the missing side of an aspect-ratio box after its parent has
+    /// supplied any definite width or height. Keeping this at the host edge
+    /// lets grid and absolute children follow the same rule as flex items
+    /// without adding platform-specific measurement behavior to native views.
+    private func aspectDimensions(
+        _ style: CraftNativeLayoutStyle,
+        width: CGFloat?,
+        height: CGFloat?
+    ) -> (width: CGFloat?, height: CGFloat?) {
+        guard let ratio = style.aspectRatio else { return (width, height) }
+        if let width, height == nil { return (width, width / ratio) }
+        if let height, width == nil { return (height * ratio, height) }
+        return (width, height)
+    }
+
     private func layoutFlex(
         _ children: [UIView],
         horizontal: Bool,
@@ -964,8 +1015,14 @@ private class CraftNativeFlowView: UIStackView {
             let crossLeading = horizontal ? style.marginTop : style.marginLeft
             let crossTrailing = horizontal ? style.marginBottom : style.marginRight
             let align = style.alignSelf ?? alignItems
-            let explicitMain = (horizontal ? style.width : style.height)?.resolve(definiteMain)
-            let explicitCross = (horizontal ? style.height : style.width)?.resolve(definiteCross)
+            let authoredMain = (horizontal ? style.width : style.height)?.resolve(definiteMain)
+            let authoredCross = (horizontal ? style.height : style.width)?.resolve(definiteCross)
+            let explicitMain = authoredMain ?? style.aspectRatio.flatMap { ratio in
+                authoredCross.map { horizontal ? $0 * ratio : $0 / ratio }
+            }
+            let explicitCross = authoredCross ?? style.aspectRatio.flatMap { ratio in
+                authoredMain.map { horizontal ? $0 / ratio : $0 * ratio }
+            }
             let minMain = (horizontal ? style.minWidth : style.minHeight)?.resolve(definiteMain)
             let maxMain = (horizontal ? style.maxWidth : style.maxHeight)?.resolve(definiteMain)
             let minCross = (horizontal ? style.minHeight : style.minWidth)?.resolve(definiteCross)
@@ -1242,11 +1299,14 @@ private class CraftNativeFlowView: UIStackView {
             let style = child.craftLayoutStyle
             let available = max(0, cellWidth - style.marginLeft - style.marginRight)
             let align = style.alignSelf ?? alignItems
-            let fixedWidth = style.width?.resolve(cellWidth) ?? (align == "stretch" ? available : nil)
+            var fixedWidth = style.width?.resolve(cellWidth)
+            var fixedHeight = style.height?.resolve(nil)
+            if fixedWidth == nil && fixedHeight == nil && align == "stretch" { fixedWidth = available }
+            (fixedWidth, fixedHeight) = aspectDimensions(style, width: fixedWidth, height: fixedHeight)
             let size = CraftNativeFlexLayout.measure(
                 child,
                 width: fixedWidth.map { min($0, available) },
-                height: style.height?.resolve(nil),
+                height: fixedHeight,
                 maxWidth: available,
                 maxHeight: CraftNativeFlexLayout.unbounded
             )
@@ -1270,16 +1330,23 @@ private class CraftNativeFlowView: UIStackView {
                 let align = style.alignSelf ?? alignItems
                 let size = sizes[index]
                 let alignment: UInt32 = align == "center" ? 1 : align == "flex-end" ? 2 : 0
+                var explicitWidth = style.width?.resolve(cellWidth)
+                var explicitHeight = style.height?.resolve(nil)
+                if explicitWidth == nil && explicitHeight == nil && align == "stretch" {
+                    explicitWidth = max(0, cellWidth - style.marginLeft - style.marginRight)
+                }
+                (explicitWidth, explicitHeight) = aspectDimensions(style, width: explicitWidth, height: explicitHeight)
                 return (
                     size.width, size.height,
-                    style.width?.resolve(cellWidth), style.height?.resolve(nil),
+                    explicitWidth, explicitHeight,
                     style.minWidth?.resolve(cellWidth), style.maxWidth?.resolve(cellWidth),
                     style.minHeight?.resolve(nil), style.maxHeight?.resolve(nil),
                     style.marginLeft, style.marginRight, style.marginTop, style.marginBottom,
                     align == "stretch", alignment
                 )
             },
-            autoRowHeight: gridAutoRows.map { $0.resolve(innerHeight) ?? 0 }
+            autoRowHeight: gridAutoRows.map { $0.resolve(innerHeight) ?? 0 },
+            alignContent: craftNativeAlignContentCode(alignContent)
         )
         if place {
             if let sharedFrames {
@@ -1289,24 +1356,41 @@ private class CraftNativeFlowView: UIStackView {
                 }
                 return CGSize(width: width, height: innerHeight ?? height)
             }
-            var rowTop = padding.top
+            let gridHeight = innerHeight ?? height
+            let gridGaps = CGFloat(max(0, rowHeights.count - 1)) * verticalGap
+            let gridFree = max(0, gridHeight - rowHeights.reduce(0, +) - gridGaps)
+            var rowLeading: CGFloat = 0
+            var rowBetween = verticalGap
+            var rowExtra: CGFloat = 0
+            switch alignContent {
+            case "center": rowLeading = gridFree / 2
+            case "flex-end": rowLeading = gridFree
+            case "space-between":
+                if rowHeights.count > 1 { rowBetween += gridFree / CGFloat(rowHeights.count - 1) }
+            case "space-around":
+                rowLeading = gridFree / CGFloat(rowHeights.count * 2)
+                rowBetween += gridFree / CGFloat(rowHeights.count)
+            case "stretch": rowExtra = gridFree / CGFloat(max(1, rowHeights.count))
+            default: break
+            }
+            var rowTop = padding.top + rowLeading
             for (index, child) in children.enumerated() {
                 let style = child.craftLayoutStyle
                 let row = index / columns
                 let column = index % columns
-                let rowHeight = rowHeights[row]
+                let rowHeight = rowHeights[row] + rowExtra
                 let size = sizes[index]
                 let align = style.alignSelf ?? alignItems
                 let availableWidth = max(0, cellWidth - style.marginLeft - style.marginRight)
                 let availableHeight = max(0, rowHeight - style.marginTop - style.marginBottom)
                 let childWidth = min(availableWidth, size.width)
-                let childHeight = align == "stretch" && style.height == nil ? availableHeight : min(availableHeight, size.height)
+                let childHeight = align == "stretch" && style.height == nil && style.aspectRatio == nil ? availableHeight : min(availableHeight, size.height)
                 let x = padding.left + CGFloat(column) * (cellWidth + horizontalGap) + style.marginLeft
                     + (align == "center" ? (availableWidth - childWidth) / 2 : align == "flex-end" ? availableWidth - childWidth : 0)
                 let y = rowTop + style.marginTop
                     + (align == "center" ? (availableHeight - childHeight) / 2 : align == "flex-end" ? availableHeight - childHeight : 0)
                 frames.append((child, CGRect(x: x, y: y, width: childWidth, height: childHeight)))
-                if column == columns - 1 || index == children.count - 1 { rowTop += rowHeight + verticalGap }
+                if column == columns - 1 || index == children.count - 1 { rowTop += rowHeight + rowBetween }
             }
         }
         return CGSize(width: width, height: innerHeight ?? height)
@@ -3581,7 +3665,7 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
         current.protocolId = node["id"] as? String
         current.style = style
         result.accessibilityIdentifier = accessibilityIdentifier(node, props: props) ?? path
-        if type != "View" && type != "SafeAreaView" && type != "KeyboardAvoidingView" && type != "ScrollView" && type != "FlatList" && type != "Modal" {
+        if type != "View" && type != "SafeAreaView" && type != "KeyboardAvoidingView" && type != "ScrollView" && type != "SectionList" && type != "FlatList" && type != "Modal" {
             result.setContentHuggingPriority(.required, for: .vertical)
         }
         applyViewStyle(style, to: result, node: current)
@@ -3893,7 +3977,7 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
                 controls: (props["controls"] as? Bool) == true,
                 resizeMode: style["resizeMode"] as? String ?? props["resizeMode"] as? String
             )
-        case "ScrollView":
+        case "ScrollView", "SectionList":
             let scroll = result as! CraftNativeScrollView
             let flexDirection = style["flexDirection"] as? String
             let direction = (props["horizontal"] as? Bool) == true
@@ -4020,7 +4104,7 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
             let icon = CraftNativeIconView()
             icon.contentMode = .scaleAspectFit
             return icon
-        case "ScrollView":
+        case "ScrollView", "SectionList":
             return CraftNativeScrollView()
         case "FlatList":
             return CraftNativeFlatList()
@@ -4055,6 +4139,7 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
         case "video": return "Video"
         case "icon": return "Icon"
         case "scrollview": return "ScrollView"
+        case "sectionlist": return "SectionList"
         case "flatlist": return "FlatList"
         case "svg": return "Svg"
         case "touchableopacity": return "TouchableOpacity"

package/dist/mobile.js

@@ -1348,6 +1348,18 @@ var health = {
     if (!craft?.health?.getSleepIntervals)
       throw new Error("Reading sleep intervals is unavailable");
     return craft.health.getSleepIntervals(options);
+  },
+  async saveMindfulSession(session) {
+    const craft = getCraftRoot();
+    if (!craft?.health?.saveMindfulSession)
+      throw new Error("Saving mindful sessions is unavailable");
+    return craft.health.saveMindfulSession(session);
+  },
+  async getMindfulSessions(options = {}) {
+    const craft = getCraftRoot();
+    if (!craft?.health?.getMindfulSessions)
+      throw new Error("Reading mindful sessions is unavailable");
+    return craft.health.getMindfulSessions(options);
   }
 };
 async function updateLiveActivity(idOrState, state) {

package/package.json

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