@momo-kits/native-kits 0.162.30 → 0.162.31

package/ios/InputMoney/InputMoney.swift

@@ -50,6 +50,7 @@ public func formatNumberToMoney(_ digits: String, currency: String = "đ") -> St
 
 public struct InputMoney: View {
     @Environment(\.appTheme) private var theme
+    @Environment(\.momoFontScale) private var fontScale
     @Binding public var text: String
 
     public var floatingValue: String
@@ -214,7 +215,7 @@ public struct InputMoney: View {
                     }
                 }
                 .padding(.horizontal, Spacing.M)
-                .frame(height: scaleSize(size == .small ? 48 : 56, 1.1))
+                .frame(height: fontScale(size == .small ? 48 : 56))
                 .background(
                     RoundedRectangle(cornerRadius: Radius.S)
                         .fill(theme.colors.background.surface)
@@ -278,7 +279,7 @@ private struct MoneyTextField: UIViewRepresentable {
         let field = UITextField()
         field.delegate = context.coordinator
         field.keyboardType = keyboardType
-        field.font = UIFont.systemFont(ofSize: scaleSize(20), weight: fontWeight)
+        field.font = UIFont.systemFont(ofSize: context.environment.momoFontScale(20), weight: fontWeight)
         field.textColor = textColor
         field.isEnabled = !isDisabled
         field.tintColor = cursorColor
@@ -295,6 +296,8 @@ private struct MoneyTextField: UIViewRepresentable {
 
     func updateUIView(_ field: UITextField, context: Context) {
         context.coordinator.parent = self
+        // Re-applied here, not just in makeUIView, so a font-scale change reaches an existing field.
+        field.font = UIFont.systemFont(ofSize: context.environment.momoFontScale(20), weight: fontWeight)
         field.isEnabled = !isDisabled
         field.textColor = textColor
         field.tintColor = cursorColor

package/ios/InputOTP/InputOTP.swift

@@ -7,12 +7,13 @@ import SwiftUI
 private struct OTPCaret: View {
     @Environment(\.appTheme) private var theme
     @State private var visible: Bool = true
+    @Environment(\.momoFontScale) private var fontScale
 
     var body: some View {
         HStack(spacing: 0) {
             Rectangle()
                 .fill(theme.colors.primary)
-                .frame(width: 1, height: scaleSize(12))
+                .frame(width: 1, height: fontScale(12))
                 .opacity(visible ? 1 : 0)
                 .animation(
                     .linear(duration: 0.5).repeatForever(autoreverses: true),

package/ios/Layout/GridContext.swift

@@ -0,0 +1,30 @@
+import SwiftUI
+
+/// Grid metrics published by a layout container (`SectionView`) so span-based children
+/// can size themselves. Mirrors `vn.momo.kits.layout.GridContext`.
+public struct GridContext: Equatable {
+    public let numberOfColumns: Int
+    public let gutter: CGFloat
+    public let sizePerSpan: CGFloat
+
+    public init(numberOfColumns: Int = 12, gutter: CGFloat = Spacing.M, sizePerSpan: CGFloat = 0) {
+        self.numberOfColumns = numberOfColumns
+        self.gutter = gutter
+        self.sizePerSpan = sizePerSpan
+    }
+
+    public func sizeForSpan(_ span: Int) -> CGFloat {
+        sizePerSpan * CGFloat(span) + gutter * CGFloat(span - 1)
+    }
+}
+
+private struct GridContextKey: EnvironmentKey {
+    static let defaultValue: GridContext? = nil
+}
+
+public extension EnvironmentValues {
+    var gridContext: GridContext? {
+        get { self[GridContextKey.self] }
+        set { self[GridContextKey.self] = newValue }
+    }
+}

package/ios/Layout/Item.swift

@@ -0,0 +1,42 @@
+import SwiftUI
+
+/// Span-sized cell inside a `SectionView`. Reads the grid published by its container;
+/// without one it just wraps its content. Mirrors `vn.momo.kits.layout.Item`.
+public struct ItemView<Content: View>: View {
+    // MARK: Lifecycle
+
+    public init(
+        widthSpan: Int = 12,
+        heightSpan: Int = 0,
+        @ViewBuilder content: @escaping () -> Content
+    ) {
+        self.widthSpan = widthSpan
+        self.heightSpan = heightSpan
+        self.content = content
+    }
+
+    // MARK: Public
+
+    public var body: some View {
+        // A VStack (not a ZStack) so multiple children flow VERTICALLY instead of stacking
+        // on top of each other — matches the React Item's flex-column content.
+        VStack(alignment: .leading, spacing: 0) { content() }
+            .frame(width: width, height: height, alignment: .topLeading)
+    }
+
+    // MARK: Private
+
+    private let widthSpan: Int
+    private let heightSpan: Int
+    private let content: () -> Content
+
+    @Environment(\.gridContext) private var grid
+
+    private var width: CGFloat? {
+        grid.map { $0.sizeForSpan(widthSpan) }
+    }
+
+    private var height: CGFloat? {
+        heightSpan > 0 ? grid.map { $0.sizeForSpan(heightSpan) } : nil
+    }
+}

package/ios/Layout/Section.swift

@@ -0,0 +1,134 @@
+import SwiftUI
+
+/// 12-column section container: horizontal margin, optional background image, and a
+/// wrapping row of children that read their span size from `\.gridContext`.
+/// Mirrors `vn.momo.kits.layout.Section`.
+public struct SectionView<Content: View>: View {
+    // MARK: Lifecycle
+
+    public init(
+        useMargin: Bool = true,
+        backgroundImage: String? = nil,
+        @ViewBuilder content: @escaping () -> Content
+    ) {
+        self.useMargin = useMargin
+        self.backgroundImage = backgroundImage
+        self.content = content
+    }
+
+    // MARK: Public
+
+    public var body: some View {
+        flow
+            .environment(\.gridContext, grid)
+            .frame(maxWidth: .infinity, alignment: .topLeading)
+            .background(widthReader)
+            .background(background)
+            .padding(.horizontal, useMargin ? Spacing.M : 0)
+    }
+
+    // MARK: Private
+
+    private static var columns: Int { 12 }
+    private static var gutter: CGFloat { Spacing.M }
+
+    private let useMargin: Bool
+    private let backgroundImage: String?
+    private let content: () -> Content
+
+    /// Width available *inside* the horizontal margin — the Compose `BoxWithConstraints` equivalent.
+    @State private var availableWidth: CGFloat = 0
+
+    private var grid: GridContext {
+        let columns = CGFloat(Self.columns)
+        // The trailing `- 1 / columns` mirrors Compose: it absorbs rounding so 12 spans
+        // plus their gutters never overflow the row by a sub-point.
+        let sizePerSpan = (availableWidth - Self.gutter * (columns - 1)) / columns - 1 / columns
+        return GridContext(numberOfColumns: Self.columns, gutter: Self.gutter, sizePerSpan: max(0, sizePerSpan))
+    }
+
+    @ViewBuilder private var flow: some View {
+        if #available(iOS 16.0, *) {
+            FlowRowLayout(gutter: Self.gutter) { content() }
+        } else {
+            // No `Layout` protocol before iOS 16: children stack instead of wrapping.
+            // Full-width (span 12) items — the common case — look identical.
+            VStack(alignment: .leading, spacing: Self.gutter) { content() }
+        }
+    }
+
+    @ViewBuilder private var background: some View {
+        if let backgroundImage {
+            ImageView(backgroundImage, contentMode: .fill).clipped()
+        }
+    }
+
+    private var widthReader: some View {
+        GeometryReader { proxy in
+            Color.clear.preference(key: SectionWidthKey.self, value: proxy.size.width)
+        }
+        .onPreferenceChange(SectionWidthKey.self) { availableWidth = $0 }
+    }
+}
+
+private struct SectionWidthKey: PreferenceKey {
+    static var defaultValue: CGFloat = 0
+
+    static func reduce(value: inout CGFloat, nextValue: () -> CGFloat) {
+        value = max(value, nextValue())
+    }
+}
+
+/// Wrapping row with equal horizontal/vertical spacing — the Compose `FlowRow` equivalent.
+@available(iOS 16.0, *)
+private struct FlowRowLayout: Layout {
+    struct Row {
+        var items: [(index: Int, size: CGSize)] = []
+        var width: CGFloat = 0
+        var height: CGFloat = 0
+    }
+
+    let gutter: CGFloat
+
+    func sizeThatFits(proposal: ProposedViewSize, subviews: Subviews, cache: inout Void) -> CGSize {
+        let maxWidth = proposal.width ?? .infinity
+        let rows = rows(for: subviews, maxWidth: maxWidth)
+        let height = rows.reduce(0) { $0 + $1.height } + gutter * CGFloat(max(0, rows.count - 1))
+        return CGSize(width: proposal.width ?? rows.map(\.width).max() ?? 0, height: height)
+    }
+
+    func placeSubviews(in bounds: CGRect, proposal: ProposedViewSize, subviews: Subviews, cache: inout Void) {
+        var y = bounds.minY
+        for row in rows(for: subviews, maxWidth: bounds.width) {
+            var x = bounds.minX
+            for item in row.items {
+                subviews[item.index].place(
+                    at: CGPoint(x: x, y: y),
+                    anchor: .topLeading,
+                    proposal: ProposedViewSize(item.size)
+                )
+                x += item.size.width + gutter
+            }
+            y += row.height + gutter
+        }
+    }
+
+    private func rows(for subviews: Subviews, maxWidth: CGFloat) -> [Row] {
+        var rows: [Row] = []
+        var current = Row()
+        for index in subviews.indices {
+            let size = subviews[index].sizeThatFits(ProposedViewSize(width: maxWidth, height: nil))
+            let widthIfAppended = current.items.isEmpty ? size.width : current.width + gutter + size.width
+            // Sub-point tolerance: spans are computed to land exactly on `maxWidth`.
+            if !current.items.isEmpty, widthIfAppended > maxWidth + 0.5 {
+                rows.append(current)
+                current = Row()
+            }
+            current.width = current.items.isEmpty ? size.width : current.width + gutter + size.width
+            current.height = max(current.height, size.height)
+            current.items.append((index, size))
+        }
+        if !current.items.isEmpty { rows.append(current) }
+        return rows
+    }
+}

package/ios/Popup/PopupNotify.swift

@@ -39,6 +39,7 @@ public struct PopupNotifyProps {
 
 public struct PopupNotify: View {
     @Environment(\.localize) private var localize
+    @Environment(\.momoFontScale) private var fontScale
 
     public let props: PopupNotifyProps
 
@@ -49,7 +50,7 @@ public struct PopupNotify: View {
     }
 
     private var maxDescriptionHeight: CGFloat {
-        scaleSize(TypographyStyle.bodyDefaultRegular.lineHeight) * 8.5
+        fontScale(TypographyStyle.bodyDefaultRegular.lineHeight) * 8.5
     }
 
     private var shouldUseColumnButtons: Bool {

package/ios/ProgressInfo/ProgressInfo.swift

@@ -254,15 +254,16 @@ private struct ProgressInfoVertical: View {
 // MARK: - Step icon
 
 private struct ProgressInfoStepIcon: View {
+    @Environment(\.momoFontScale) private var fontScale
     let index: Int
     let size: ProgressInfoSize
     let useNumber: Bool
     let customIcon: String?
 
     var body: some View {
-        let containerSize = scaleSize(size == .small ? 16 : 24)
-        let dotSize = scaleSize(size == .small ? 6 : 8)
-        let iconSize = scaleSize(size == .small ? 12 : 16)
+        let containerSize = fontScale(size == .small ? 16 : 24)
+        let dotSize = fontScale(size == .small ? 6 : 8)
+        let iconSize = fontScale(size == .small ? 12 : 16)
 
         ZStack {
             Circle()

package/ios/Rating/Rating.swift

@@ -15,6 +15,7 @@ public enum RatingSize {
 }
 
 public struct Rating: View {
+    @Environment(\.momoFontScale) private var fontScale
     private let numOfStars: Int
     private let rating: Float
     private let onRatingChange: ((Int) -> Void)?
@@ -44,7 +45,7 @@ public struct Rating: View {
     private func star(at index: Int) -> some View {
         let icon = Icon(
             source: starIcon(at: index),
-            size: scaleSize(size.iconSize),
+            size: fontScale(size.iconSize),
             color: starColor(at: index)
         )
 

package/ios/Stepper/Stepper.swift

@@ -84,6 +84,7 @@ private struct StepperButton: View {
 
 private struct StepperNumberView: View {
     @Environment(\.appTheme) private var theme
+    @Environment(\.momoFontScale) private var fontScale
 
     @Binding var text: String
     var size: StepperSize
@@ -105,7 +106,7 @@ private struct StepperNumberView: View {
                 MomoText(text, typography: .descriptionDefaultRegular, color: textColor)
             }
         }
-        .font(.system(size: scaleSize(12)))
+        .font(.system(size: fontScale(12)))
         .ignoreBoldTextSetting()
         .foregroundColor(textColor)
         .frame(minWidth: specs.numberMinWidth)

package/ios/SuggestAction/SuggestAction.swift

@@ -3,6 +3,7 @@ import Foundation
 
 public struct SuggestAction: View {
     @Environment(\.appTheme) private var theme
+    @Environment(\.momoFontScale) private var fontScale
 
     private let message: String
     private let buttonTitle: String
@@ -32,7 +33,7 @@ public struct SuggestAction: View {
 
     // Builds an attributed string with `boldMessage` (case-insensitive) emphasized.
     private var annotatedMessage: AttributedString {
-        let baseFont = Font.system(size: scaleSize(TypographyStyle.bodyDefaultRegular.fontSize), weight: .regular)
+        let baseFont = Font.system(size: fontScale(TypographyStyle.bodyDefaultRegular.fontSize), weight: .regular)
         var attributed = AttributedString(message)
         attributed.font = baseFont
 
@@ -44,7 +45,7 @@ public struct SuggestAction: View {
 
         if let boldRange = Range(range, in: attributed) {
             attributed[boldRange].font = Font.system(
-                size: scaleSize(TypographyStyle.bodyDefaultRegular.fontSize),
+                size: fontScale(TypographyStyle.bodyDefaultRegular.fontSize),
                 weight: .bold
             )
         }

package/ios/Tag/Tag.swift

@@ -1,6 +1,7 @@
 import SwiftUI
 
 public struct Tag: View {
+    @Environment(\.momoFontScale) private var fontScale
     public enum TagSize {
         case large
         case medium
@@ -71,7 +72,7 @@ public struct Tag: View {
             }
             MomoText(label, typography: .labelSMedium, color: labelColor)
         }
-        .frame(height: scaleSize(size.height))
+        .frame(height: fontScale(size.height))
         .padding(.horizontal, Spacing.S)
         .background(
             RoundedRectangle(cornerRadius: Radius.S, style: .continuous)

package/ios/Template/TrustBanner/TrustBanner.swift

@@ -74,7 +74,8 @@ public struct TrustBanner: View {
                 .scaledToFit()
                 .frame(width: 64, height: 64)
             VStack(alignment: .leading){
-                Text(applicationEnvironment.config?.trustBanner?.content[localize.currentLanguage] ?? defaultBanner.content[localize.currentLanguage])
+                Text(applicationEnvironment.config?.trustBanner?.content[localize.currentLanguage]
+                     ?? localize.translateData(defaultBanner.content))
                     .foregroundColor(Color(hex: "484848"))
                     .lineLimit(2)
                     .font(.system(size: 13, weight: Font.Weight.regular))
@@ -83,7 +84,8 @@ public struct TrustBanner: View {
                     .padding(.bottom, 8)
                 HStack {
                     HStack(spacing: 0) {
-                        Text(applicationEnvironment.config?.trustBanner?.subContent[localize.currentLanguage] ?? defaultBanner.subContent[localize.currentLanguage])
+                        Text(applicationEnvironment.config?.trustBanner?.subContent[localize.currentLanguage]
+                             ?? localize.translateData(defaultBanner.subContent))
                             .foregroundColor(Colors.pink03)
                             .font(.system(size: 13, weight: .bold))
                             .ignoreBoldTextSetting()

package/ios/Title/Title.swift

@@ -28,6 +28,7 @@ public enum TitleButtonSize {
 
 public struct Title: View {
     @Environment(\.appTheme) private var theme
+    @Environment(\.momoFontScale) private var fontScale
 
     private let title: String
     private let type: TitleType
@@ -152,10 +153,10 @@ public struct Title: View {
 
     private var titleText: some View {
         SwiftUI.Text(title)
-            .font(.system(size: scaleSize(titleFontSize), weight: titleFontWeight))
+            .font(.system(size: fontScale(titleFontSize), weight: titleFontWeight))
             .ignoreBoldTextSetting()
             .foregroundColor(theme.colors.text.default)
-            .lineSpacing(scaleSize(titleLineHeight) - scaleSize(titleFontSize))
+            .lineSpacing(fontScale(titleLineHeight) - fontScale(titleFontSize))
             .lineLimit(titleMaxLines)
             .truncationMode(.tail)
     }

package/ios/Tooltip/Tooltip.swift

@@ -469,11 +469,12 @@ private struct TooltipSecondaryButton: View {
 }
 
 private struct TooltipIconButton: View {
+    @Environment(\.momoFontScale) private var fontScale
     let icon: String
     let onPress: () -> Void
 
     var body: some View {
-        let iconButtonSize = scaleSize(36)
+        let iconButtonSize = fontScale(36)
         SwiftUI.Button(action: onPress) {
             Icon(source: icon, size: 24)
                 .frame(width: iconButtonSize, height: iconButtonSize)

package/ios/Typography/FontScale.swift

@@ -0,0 +1,103 @@
+// File: ios/Typography/FontScale.swift
+// Created At: 2026-08-06 10:00:00 +07:00
+// Created By: AI
+// AI Agent: Claude Code
+// Model: claude-opus-5
+
+// AI-GENERATED START: reactive font-scale snapshot injected through the environment
+import SwiftUI
+
+/// Immutable snapshot of the kit's font-scale inputs. The formula is a 1:1 port of Compose's
+/// `scaleSize()` (`const/Typography.kt`): the device-width scale and the OS Dynamic Type scale are
+/// computed independently and the larger one wins.
+public struct FontScale: Equatable {
+    private static let defaultScreenSize: CGFloat = 375
+    private static let maxFontScale: CGFloat = 1.5
+    private static let maxDeviceScale: CGFloat = 5
+
+    public let userScaleRate: CGFloat
+    public let useOSScaleRate: Bool
+    /// OS Dynamic Type factor at the time the snapshot was taken.
+    public let osFontScale: CGFloat
+
+    public init(userScaleRate: CGFloat = 1, useOSScaleRate: Bool = true, osFontScale: CGFloat = 1) {
+        self.userScaleRate = userScaleRate
+        self.useOSScaleRate = useOSScaleRate
+        self.osFontScale = osFontScale
+    }
+
+    /// `callAsFunction` so call sites keep reading like Compose's `scaleSize(16)`.
+    public func callAsFunction(_ size: CGFloat) -> CGFloat {
+        guard useOSScaleRate else { return size * userScaleRate }
+
+        // Device width is read live rather than snapshotted, matching Compose's
+        // getScreenDimensions() read inside scaleSize(), so a rotation or split-view resize counts.
+        let deviceScale = UIScreen.main.bounds.width / Self.defaultScreenSize
+
+        var deviceScaled = size
+        var osScaled = size
+        if deviceScale > 1 {
+            deviceScaled = min(size * deviceScale, size + Self.maxDeviceScale)
+        }
+        if osFontScale > 1 {
+            osScaled = min(size * osFontScale, size * Self.maxFontScale)
+        }
+        return max(deviceScaled, osScaled)
+    }
+
+    /// `.system(size:)` is a fixed-size font — SwiftUI does not Dynamic-Type it — so the scale has to
+    /// be baked into the point size here, and there is no double-scaling to undo.
+    public func font(size: CGFloat, weight: Font.Weight = .regular) -> Font {
+        .system(size: self(size), weight: weight)
+    }
+
+    /// A host-pushed mini-app context wins per field, matching Compose's
+    /// `context?.useOSScaleRate ?: KitFontScale.useOSScaleRate`.
+    public func overriding(userScaleRate: CGFloat?, useOSScaleRate: Bool?) -> FontScale {
+        guard userScaleRate != nil || useOSScaleRate != nil else { return self }
+        return FontScale(
+            userScaleRate: userScaleRate ?? self.userScaleRate,
+            useOSScaleRate: useOSScaleRate ?? self.useOSScaleRate,
+            osFontScale: osFontScale
+        )
+    }
+}
+
+private struct FontScaleKey: EnvironmentKey {
+    /// Computed, never stored: a bare `UIHostingController` root that never got `.momoFontScale()`
+    /// still reads the live store instead of a value frozen at first access.
+    static var defaultValue: FontScale { FontScaleStore.shared.snapshot }
+}
+
+public extension EnvironmentValues {
+    var momoFontScale: FontScale {
+        get { self[FontScaleKey.self] }
+        set { self[FontScaleKey.self] = newValue }
+    }
+}
+
+public extension View {
+    /// Injects a Dynamic-Type-observing font scale and re-renders this subtree on change.
+    /// Use at every `UIHostingController` root that is not inside a `NavigationContainer`.
+    func momoFontScale(_ store: FontScaleStore = .shared, context: MiniAppContext? = nil) -> some View {
+        modifier(MomoFontScaleModifier(store: store, context: context))
+    }
+}
+
+/// `@ObservedObject` is load-bearing, same as `MomoLocalizeModifier`: `@Environment(\.momoFontScale)`
+/// only invalidates when the boxed snapshot changes, which requires *this* body to re-run on publish.
+private struct MomoFontScaleModifier: ViewModifier {
+    @ObservedObject var store: FontScaleStore
+    let context: MiniAppContext?
+
+    func body(content: Content) -> some View {
+        content.environment(
+            \.momoFontScale,
+            store.snapshot.overriding(
+                userScaleRate: context?.userScaleRate,
+                useOSScaleRate: context?.useOSScaleRate
+            )
+        )
+    }
+}
+// AI-GENERATED END: reactive font-scale snapshot injected through the environment

package/ios/Typography/FontScaleStore.swift

@@ -1,19 +1,58 @@
-import CoreGraphics
-
-/// App-wide font-scale preference for the SwiftUI kit. An exported holder the host writes once at
-/// app startup (from the cache-backed `FontScaleProvider`); `scaleSize`/`appFont` read the snapshot.
-/// No realtime: the SwiftUI kit has no navigation container to scope reactive updates, so a startup
-/// snapshot is enough. When `useOSScaleRate` is false the kit applies `userScaleRate` instead of the
-/// OS Dynamic Type factor.
-public final class FontScaleStore {
+import SwiftUI
+
+/// App-wide font-scale inputs for the SwiftUI kit, and the single place they publish from.
+/// The host writes `update(...)` at startup (from the cache-backed `FontScaleProvider`) and again
+/// whenever the in-app font-size preference changes; the OS Dynamic Type factor is tracked here.
+/// Mirrors Compose's `KitFontScale` + `ProvideOsFontScale` pair, including its live behaviour —
+/// views re-render on change as long as the subtree got `.momoFontScale()` (`NavigationContainer`
+/// applies it). When `useOSScaleRate` is false the kit applies `userScaleRate` instead of the OS factor.
+public final class FontScaleStore: ObservableObject {
     public static let shared = FontScaleStore()
-    private init() {}
 
-    public private(set) var userScaleRate: CGFloat = 1
-    public private(set) var useOSScaleRate: Bool = true
+    @Published public private(set) var userScaleRate: CGFloat = 1
+    @Published public private(set) var useOSScaleRate: Bool = true
+    @Published public private(set) var osFontScale: CGFloat = FontScaleStore.currentOsFontScale()
+
+    private init() {
+        NotificationCenter.default.addObserver(
+            self,
+            selector: #selector(contentSizeCategoryDidChange),
+            name: UIContentSizeCategory.didChangeNotification,
+            object: nil
+        )
+    }
+
+    public var snapshot: FontScale {
+        FontScale(
+            userScaleRate: userScaleRate,
+            useOSScaleRate: useOSScaleRate,
+            osFontScale: osFontScale
+        )
+    }
 
     public func update(userScaleRate: CGFloat, useOSScaleRate: Bool) {
-        self.userScaleRate = userScaleRate
-        self.useOSScaleRate = useOSScaleRate
+        onMain {
+            // Re-assigning an unchanged value would still publish and invalidate every kit subtree.
+            if self.userScaleRate != userScaleRate { self.userScaleRate = userScaleRate }
+            if self.useOSScaleRate != useOSScaleRate { self.useOSScaleRate = useOSScaleRate }
+        }
+    }
+
+    @objc private func contentSizeCategoryDidChange() {
+        let next = Self.currentOsFontScale()
+        guard next != osFontScale else { return }
+        osFontScale = next
+    }
+
+    /// Same factor Compose's iOS `ProvideOsFontScale` derives from
+    /// `UIFont.preferredFont(forTextStyle: .body).pointSize / 17`, so both iOS surfaces scale alike.
+    static func currentOsFontScale() -> CGFloat {
+        let base = UIFont.systemFont(ofSize: UIFont.labelFontSize)
+        return UIFontMetrics.default.scaledFont(for: base).pointSize / base.pointSize
+    }
+
+    /// Synchronous when already on main — an async hop would defer the change by a frame.
+    private func onMain(_ work: @escaping () -> Void) {
+        if Thread.isMainThread { work() } else { DispatchQueue.main.async(execute: work) }
     }
 }