@swiftbrowser/swift 0.2.0 → 0.3.0

package/Package.swift

@@ -102,9 +102,9 @@ let package = Package(
                 // (`canImport(OSLog)`) and the macro must link it: the CLI sets
                 // SWIFT_BUILD_SCRIPT_ENVIRONMENT, which turns that logging off
                 // (toolchain.ts). This repository's own builds always compile
-                // swift-syntax (SwiftDataTests links the macro target), so in its
-                // Package.swift the macro also links os, whichever of the two
-                // builds first (a line manifest.mjs leaves out of the published one).
+                // swift-syntax (SwiftDataTests links the macro target): without
+                // that variable, the end of its Package.swift has the macro link
+                // os too (lines manifest.mjs leaves out of the published one).
             ],
             path: "Sources/SwiftDataMacros"
         ),

package/Sources/SwiftUI/API/AlignmentGuides.swift

@@ -26,9 +26,12 @@ extension HorizontalAlignment {
         }
     }
 
-    /// Where a list row's separator starts: accepted, the page draws full-width separators.
-    public static let listRowSeparatorLeading = HorizontalAlignment(name: "leading")
-    public static let listRowSeparatorTrailing = HorizontalAlignment(name: "trailing")
+    /// Where a list row's separator starts: accepted, the page draws full-width
+    /// separators. A guide of its own, which no stack or frame aligns by: as
+    /// `.leading`, Ice Cubes' `.alignmentGuide(.listRowSeparatorLeading) { _ in -100 }`
+    /// moved its embedded posts 100 points right in their leading `VStack`.
+    public static let listRowSeparatorLeading = HorizontalAlignment(name: "listRowSeparatorLeading")
+    public static let listRowSeparatorTrailing = HorizontalAlignment(name: "listRowSeparatorTrailing")
 }
 
 extension VerticalAlignment {

package/Sources/SwiftUI/API/ColorSpaces.swift

@@ -93,7 +93,7 @@ extension Color {
             case "primary": return dark ? resolved(1, 1, 1, a) : resolved(0, 0, 0, a)
             case "secondary":
                 return dark ? resolved(0.922, 0.922, 0.961, 0.6 * a) : resolved(0.235, 0.235, 0.263, 0.6 * a)
-            case "accent": return dark ? resolved(0.039, 0.518, 1, a) : resolved(0, 0.478, 1, a)
+            case "accent": return dark ? resolved(0, 0.569, 1, a) : resolved(0, 0.533, 1, a)
             case "clear": return resolved(0, 0, 0, 0)
             default:
                 guard let (light, darkValue) = Color.semanticValues[name] else { return resolved(0.5, 0.5, 0.5, a) }
@@ -113,18 +113,18 @@ extension Color {
     static let semanticValues: [String: (light: (Double, Double, Double, Double), dark: (Double, Double, Double, Double))] = {
         func rgb(_ r: Double, _ g: Double, _ b: Double, _ a: Double = 1) -> (Double, Double, Double, Double) { (r / 255, g / 255, b / 255, a) }
         return [
-            "red": (rgb(255, 59, 48), rgb(255, 69, 58)),
-            "orange": (rgb(255, 149, 0), rgb(255, 159, 10)),
-            "yellow": (rgb(255, 204, 0), rgb(255, 214, 10)),
+            "red": (rgb(255, 56, 60), rgb(255, 66, 69)),
+            "orange": (rgb(255, 141, 40), rgb(255, 146, 48)),
+            "yellow": (rgb(255, 204, 0), rgb(255, 214, 0)),
             "green": (rgb(52, 199, 89), rgb(48, 209, 88)),
-            "mint": (rgb(0, 199, 190), rgb(99, 230, 226)),
-            "teal": (rgb(48, 176, 199), rgb(64, 200, 224)),
-            "cyan": (rgb(50, 173, 230), rgb(100, 210, 255)),
-            "blue": (rgb(0, 122, 255), rgb(10, 132, 255)),
-            "indigo": (rgb(88, 86, 214), rgb(94, 92, 230)),
-            "purple": (rgb(175, 82, 222), rgb(191, 90, 242)),
+            "mint": (rgb(0, 200, 179), rgb(0, 218, 195)),
+            "teal": (rgb(0, 195, 208), rgb(0, 210, 224)),
+            "cyan": (rgb(0, 192, 232), rgb(60, 211, 254)),
+            "blue": (rgb(0, 136, 255), rgb(0, 145, 255)),
+            "indigo": (rgb(97, 85, 245), rgb(109, 124, 255)),
+            "purple": (rgb(203, 48, 224), rgb(219, 52, 242)),
             "pink": (rgb(255, 45, 85), rgb(255, 55, 95)),
-            "brown": (rgb(162, 132, 94), rgb(172, 142, 104)),
+            "brown": (rgb(172, 127, 94), rgb(183, 138, 102)),
             "gray": (rgb(142, 142, 147), rgb(142, 142, 147)),
             "systemBackground": (rgb(255, 255, 255), rgb(0, 0, 0)),
             "secondarySystemBackground": (rgb(242, 242, 247), rgb(28, 28, 30)),

package/Sources/SwiftUI/API/Effects.swift

@@ -227,13 +227,30 @@ nonisolated extension View {
     public func contentTransition(_ transition: ContentTransition) -> some View { self }
     public func textSelection<S: TextSelectability>(_ selectability: S) -> some View { self }
     public func toolbarRole(_ role: ToolbarRole) -> some View { self }
-    public func controlSize(_ size: ControlSize) -> some View { self }
+    /// The size of the controls inside; a bordered button's height follows it
+    /// (the page: `large` and `extraLarge` are taller).
+    public func controlSize(_ size: ControlSize) -> some View {
+        environment(\.controlSize, size)
+    }
 }
 
 public enum Prominence: Hashable, Sendable { case standard, increased }
 
-/// `.controlSize`: accepted for source compatibility; controls keep one size.
-public enum ControlSize: Hashable, CaseIterable, Sendable { case mini, small, regular, large, extraLarge }
+/// `.controlSize`: bordered buttons take it (props `controlSize` when it is not
+/// `regular`); other controls keep one size.
+public enum ControlSize: Hashable, CaseIterable, Sendable {
+    case mini, small, regular, large, extraLarge
+
+    var _name: String {
+        switch self {
+        case .mini: "mini"
+        case .small: "small"
+        case .regular: "regular"
+        case .large: "large"
+        case .extraLarge: "extraLarge"
+        }
+    }
+}
 
 public struct SymbolVariants: Hashable, Sendable {
     let name: String

package/Sources/SwiftUI/API/Environment.swift

@@ -166,6 +166,12 @@ public struct EnvironmentValues {
         set { self[_ButtonStyleKey.self] = newValue }
     }
 
+    /// `.controlSize(_:)`; `regular` by default.
+    public var controlSize: ControlSize {
+        get { self[_ControlSizeKey.self] }
+        set { self[_ControlSizeKey.self] = newValue }
+    }
+
     var _textFieldStyle: String {
         get { self[_TextFieldStyleKey.self] }
         set { self[_TextFieldStyleKey.self] = newValue }
@@ -214,6 +220,7 @@ enum _LayoutDirectionKey: EnvironmentKey { static let defaultValue = LayoutDirec
 enum _FontKey: EnvironmentKey { static let defaultValue: Font? = nil }
 enum _DisplayScaleKey: EnvironmentKey { static let defaultValue: CGFloat = 3 }
 enum _ButtonStyleKey: EnvironmentKey { static let defaultValue = "automatic" }
+enum _ControlSizeKey: EnvironmentKey { static let defaultValue = ControlSize.regular }
 enum _TextFieldStyleKey: EnvironmentKey { static let defaultValue = "plain" }
 
 // MARK: - @Environment

package/Sources/SwiftUI/API/Gauge.swift

@@ -35,6 +35,12 @@ public struct AccessoryCircularCapacityGaugeStyle: GaugeStyle, _NamedGaugeStyle,
     var _name: String { "accessoryCircularCapacity" }
 }
 
+/// A determinate `ProgressView`'s gauge: the label above the bar in the
+/// body font, the current value label under it (the page lays it out).
+struct _ProgressGaugeStyle: GaugeStyle, _NamedGaugeStyle, Sendable {
+    var _name: String { "progress" }
+}
+
 extension GaugeStyle where Self == DefaultGaugeStyle {
     public static var automatic: DefaultGaugeStyle { DefaultGaugeStyle() }
 }
@@ -163,10 +169,11 @@ extension Gauge: _HostView {
 
 // MARK: - ProgressView
 
-/// Progress toward a total. A determinate progress view draws as a
-/// `linearCapacity` gauge with its label; an indeterminate one (no value)
-/// has no spinner in the protocol and shows its label, or an hourglass
-/// symbol when it has none.
+/// Progress toward a total. A determinate progress view draws as a gauge
+/// (style `progress`: its label above the bar, its current value label under
+/// it); an indeterminate one (no value) is
+/// the spinner symbol (`progress.indicator`, which the page animates) with its
+/// label under it, as iOS draws them.
 public struct ProgressView<Label: View, CurrentValueLabel: View>: View {
     /// Progress in 0…1, nil when indeterminate.
     let fraction: Double?
@@ -178,16 +185,24 @@ public struct ProgressView<Label: View, CurrentValueLabel: View>: View {
             Gauge(value: fraction, in: 0...1) {
                 if let label { label }
             } currentValueLabel: {
-                if let currentValueLabel { currentValueLabel }
+                if let currentValueLabel { currentValueLabel.foregroundStyle(.secondary) }
             }
-            .gaugeStyle(.linearCapacity)
+            .gaugeStyle(_ProgressGaugeStyle())
         } else if let label {
-            label.foregroundStyle(.secondary)
+            VStack(spacing: 8) {
+                activityIndicator
+                label.foregroundStyle(.secondary)
+            }
         } else {
-            Image(systemName: "hourglass").foregroundStyle(.secondary)
+            activityIndicator
         }
     }
 
+    /// iOS's activity indicator is 20pt across whatever the font around it.
+    private var activityIndicator: some View {
+        Image(systemName: "progress.indicator").font(.system(size: 20)).foregroundStyle(.secondary)
+    }
+
     static func fraction<V: BinaryFloatingPoint>(_ value: V?, total: V) -> Double? {
         guard let value, total > 0 else { return nil }
         return max(0, min(1, Double(value) / Double(total)))

package/Sources/SwiftUI/API/Layout.swift

@@ -81,6 +81,10 @@ extension _ShapeView: _HostView {
                     object["dash"] = .array(style.dash.map(_JSON.number))
                     object["dashPhase"] = .number(style.dashPhase)
                 }
+            } else if let style = strokeStyle, !style.dash.isEmpty {
+                // A built-in shape's border can only be dashed or not: the page
+                // draws CSS dashes for any pattern.
+                object["dash"] = .array(style.dash.map(_JSON.number))
             }
             stroke = .object(object)
         }

package/Sources/SwiftUI/API/Modifiers.swift

@@ -134,14 +134,20 @@ extension _StyledGroup: _GroupView {
         // child of its list, which is how the layout recognizes it).
         if let section = content as? any _SectionView { return [section._stylingRows(style)] }
         if let group = content as? any _GroupView, group._spreads {
-            return group._children.map { _StyledView(content: AnyView($0), style: style) }
+            let target = _spreadTarget(group)
+            var children = target._children
+            // A view of the group that is absent (`if locked { badge }` when not
+            // locked) gets no styled element: an empty one would take a stack's
+            // spacing. Keyed children keep their places.
+            if target._keys == nil { children.removeAll(where: _rendersNothing) }
+            return children.map { _StyledView(content: AnyView($0), style: style) }
         }
         return [_StyledView(content: content, style: style)]
     }
 
     var _keys: [AnyHashable]? {
         if let group = content as? any _GroupView, group._spreads {
-            return group._keys
+            return _spreadTarget(group)._keys
         }
         return nil
     }

package/Sources/SwiftUI/API/Picker.swift

@@ -172,7 +172,8 @@ func _systemImage(of view: any View) -> String? {
 
 // MARK: - Form
 
-/// A container for grouped controls, drawn as a grouped list.
+/// A container for grouped controls, drawn as an inset grouped list (what
+/// iOS's automatic form style is on iPhone: cards inset from the edges).
 public struct Form<Content: View> {
     let content: Content
     public init(@ViewBuilder content: () -> Content) { self.content = content() }
@@ -180,6 +181,6 @@ public struct Form<Content: View> {
 extension Form: _PrimitiveView {}
 extension Form: _HostView {
     var _kind: String { "list" }
-    func _props(in environment: EnvironmentValues) -> _JSON { .object(["style": .string("grouped")]) }
+    func _props(in environment: EnvironmentValues) -> _JSON { .object(["style": .string("insetGrouped")]) }
     var _content: [any View] { [content] }
 }

package/Sources/SwiftUI/API/Primitives.swift

@@ -454,11 +454,13 @@ extension Button: _PrimitiveView {}
 extension Button: _HostView {
     var _kind: String { "button" }
     func _props(in environment: EnvironmentValues) -> _JSON {
-        .object([
+        var props: [String: _JSON] = [
             // A custom `ButtonStyle` draws its own look: `plain` (ButtonStyles.swift).
             "style": .string(environment._buttonStyle == _CustomButtonStyle.marker ? "plain" : environment._buttonStyle),
             "role": role.map { .string($0.name) } ?? .null,
-        ])
+        ]
+        if environment.controlSize != .regular { props["controlSize"] = .string(environment.controlSize._name) }
+        return .object(props)
     }
     var _content: [any View] { [label] }
     var _handler: ((_JSON) -> Void)? {

package/Sources/SwiftUI/API/SectionSupplements.swift

@@ -5,11 +5,10 @@
 // other view becomes a child of the `section`: a `sectionheader` before the
 // rows and a `sectionfooter` after them, each with the view inside (props
 // `{}`). In a list the page lays the header view out above the section's card
-// and the footer view below it, in the content width, in the footnote font
-// and the secondary color; outside a list (a `Section` in a `LazyVStack`) they
-// stack with the rows. As for a string header, the texts in a header view
-// are upper-cased (the environment's `textCase`, which `.textCase(nil)`
-// inside the header undoes).
+// and the footer view below it, in the content width and the secondary
+// color (headers in the headline font, footers in the footnote font); outside a list (a `Section` in a `LazyVStack`) they
+// stack with the rows. As in iOS 26, headers keep their case (iOS 18 and
+// earlier upper-cased them).
 
 /// A section's view header or footer: kind `sectionheader` or `sectionfooter`.
 struct _SectionSupplement {
@@ -20,16 +19,7 @@ extension _SectionSupplement: _PrimitiveView {}
 extension _SectionSupplement: _HostView {
     var _kind: String { kind }
     func _props(in environment: EnvironmentValues) -> _JSON { .object([:]) }
-    var _content: [any View] {
-        guard kind == "sectionheader" else { return [content] }
-        return [_withEnvironment(content) { $0.textCase = .uppercase }]
-    }
-}
-
-/// `content.environment(…)` for an existential view.
-private func _withEnvironment(_ view: any View, _ apply: @escaping (inout EnvironmentValues) -> Void) -> any View {
-    func open<V: View>(_ content: V) -> any View { _EnvironmentView(content: content, apply: apply) }
-    return open(view)
+    var _content: [any View] { [content] }
 }
 
 /// A header or footer view as the section stores it: a `Text` (or an

package/Sources/SwiftUI/API/ShapeStyle.swift

@@ -2,7 +2,8 @@
 /// A style serializes to the JSON the renderer resolves (see
 /// docs/ops-protocol.md, "Phase 6 additions"): a `Color`'s own forms, or
 /// `{"hierarchical": 1...4}`, `{"linearGradient": {...}}`,
-/// `{"radialGradient": {...}}`, `{"colorGradient": color}`, `{"material": name}`.
+/// `{"radialGradient": {...}}`, `{"angularGradient": {...}}`,
+/// `{"colorGradient": color}`, `{"material": name}`.
 ///
 /// A style of an app's own (iOS 17) implements `resolve(in:)`, returning a
 /// style it is made of; it is encoded as that style, resolved in the page's
@@ -240,6 +241,80 @@ public struct RadialGradient: ShapeStyle, Equatable {
     }
 }
 
+/// A gradient swept around a center, clockwise from `startAngle` (0° points
+/// right) to `endAngle`; equal angles sweep the whole turn. The renderer draws
+/// a CSS `conic-gradient`.
+public struct AngularGradient: ShapeStyle, Equatable {
+    public var gradient: Gradient
+    public var center: UnitPoint
+    public var startAngle: Angle
+    public var endAngle: Angle
+
+    public init(gradient: Gradient, center: UnitPoint, startAngle: Angle = .zero, endAngle: Angle = .zero) {
+        self.gradient = gradient
+        self.center = center
+        self.startAngle = startAngle
+        self.endAngle = endAngle
+    }
+
+    public init(colors: [Color], center: UnitPoint, startAngle: Angle = .zero, endAngle: Angle = .zero) {
+        self.init(gradient: Gradient(colors: colors), center: center, startAngle: startAngle, endAngle: endAngle)
+    }
+
+    public init(stops: [Gradient.Stop], center: UnitPoint, startAngle: Angle = .zero, endAngle: Angle = .zero) {
+        self.init(gradient: Gradient(stops: stops), center: center, startAngle: startAngle, endAngle: endAngle)
+    }
+
+    /// A conic gradient: the whole turn, starting at `angle`.
+    public init(gradient: Gradient, center: UnitPoint, angle: Angle = .zero) {
+        self.init(gradient: gradient, center: center, startAngle: angle, endAngle: .degrees(angle.degrees + 360))
+    }
+
+    public init(colors: [Color], center: UnitPoint, angle: Angle = .zero) {
+        self.init(gradient: Gradient(colors: colors), center: center, angle: angle)
+    }
+
+    public init(stops: [Gradient.Stop], center: UnitPoint, angle: Angle = .zero) {
+        self.init(gradient: Gradient(stops: stops), center: center, angle: angle)
+    }
+
+    public var _json: _JSON {
+        let end = endAngle == startAngle ? startAngle.degrees + 360 : endAngle.degrees
+        return .object(["angularGradient": .object([
+            "stops": gradient._stopsJSON,
+            "center": center._json,
+            "startAngle": .number(startAngle.degrees),
+            "endAngle": .number(end),
+        ])])
+    }
+}
+
+extension ShapeStyle where Self == AngularGradient {
+    public static func angularGradient(_ gradient: Gradient, center: UnitPoint, startAngle: Angle, endAngle: Angle) -> AngularGradient {
+        AngularGradient(gradient: gradient, center: center, startAngle: startAngle, endAngle: endAngle)
+    }
+
+    public static func angularGradient(colors: [Color], center: UnitPoint, startAngle: Angle, endAngle: Angle) -> AngularGradient {
+        AngularGradient(colors: colors, center: center, startAngle: startAngle, endAngle: endAngle)
+    }
+
+    public static func angularGradient(stops: [Gradient.Stop], center: UnitPoint, startAngle: Angle, endAngle: Angle) -> AngularGradient {
+        AngularGradient(stops: stops, center: center, startAngle: startAngle, endAngle: endAngle)
+    }
+
+    public static func conicGradient(_ gradient: Gradient, center: UnitPoint, angle: Angle = .zero) -> AngularGradient {
+        AngularGradient(gradient: gradient, center: center, angle: angle)
+    }
+
+    public static func conicGradient(colors: [Color], center: UnitPoint, angle: Angle = .zero) -> AngularGradient {
+        AngularGradient(colors: colors, center: center, angle: angle)
+    }
+
+    public static func conicGradient(stops: [Gradient.Stop], center: UnitPoint, angle: Angle = .zero) -> AngularGradient {
+        AngularGradient(stops: stops, center: center, angle: angle)
+    }
+}
+
 extension ShapeStyle where Self == LinearGradient {
     public static func linearGradient(_ gradient: Gradient, startPoint: UnitPoint, endPoint: UnitPoint) -> LinearGradient {
         LinearGradient(gradient: gradient, startPoint: startPoint, endPoint: endPoint)
@@ -292,6 +367,12 @@ extension RadialGradient: _HostView {
     func _props(in environment: EnvironmentValues) -> _JSON { _gradientViewProps(self) }
 }
 
+extension AngularGradient: _PrimitiveView {}
+extension AngularGradient: _HostView {
+    var _kind: String { "shape" }
+    func _props(in environment: EnvironmentValues) -> _JSON { _gradientViewProps(self) }
+}
+
 extension AnyGradient: _PrimitiveView {}
 extension AnyGradient: _HostView {
     var _kind: String { "shape" }

package/Sources/SwiftUI/API/View.swift

@@ -37,7 +37,37 @@ protocol _GroupView: _TraitBearing {
 
 extension _GroupView {
     var _keys: [AnyHashable]? { nil }
-    var _spreads: Bool { _keys != nil || _children.count != 1 }
+    var _spreads: Bool {
+        if _keys != nil { return true }
+        let children = _children
+        if children.count != 1 { return true }
+        // A wrapper that adds nothing (`Group { a; b }`, `if c { a; b }`)
+        // spreads as the group it holds does.
+        guard self is any _TransparentGroup, let inner = children[0] as? any _GroupView else { return false }
+        return inner._spreads
+    }
+}
+
+/// A group that only holds what it wraps (`Group`, `AnyView`, an optional, a
+/// conditional, a tuple, `EmptyView`): a modifier applied to it applies to the
+/// views of the group it holds, as if written on that group (`_spreadTarget`).
+protocol _TransparentGroup: _GroupView {}
+
+/// Whether `view` contributes no view at all: `EmptyView`, an absent
+/// optional, or a wrapper or tuple of nothing but those.
+func _rendersNothing(_ view: any View) -> Bool {
+    guard let group = view as? any _TransparentGroup else { return false }
+    return group._children.allSatisfy(_rendersNothing)
+}
+
+/// The group whose children a modifier applied to `group` styles one by one:
+/// `group`, or the group a transparent wrapper of one child holds
+/// (`Group { a; b }.font(…)` styles `a` and `b`).
+func _spreadTarget(_ group: any _GroupView) -> any _GroupView {
+    guard group is any _TransparentGroup, group._keys == nil else { return group }
+    let children = group._children
+    guard children.count == 1, let inner = children[0] as? any _GroupView, inner._spreads else { return group }
+    return _spreadTarget(inner)
 }
 
 /// A view that becomes an element in the render tree (see docs/ops-protocol.md).
@@ -97,6 +127,7 @@ public struct EmptyView: Sendable {
     public init() {}
 }
 extension EmptyView: _PrimitiveView {}
+extension EmptyView: _TransparentGroup {}
 extension EmptyView: _GroupView {
     var _children: [any View] { [] }
 }
@@ -111,6 +142,7 @@ public struct TupleView<T> {
     }
 }
 extension TupleView: _PrimitiveView {}
+extension TupleView: _TransparentGroup {}
 extension TupleView: _GroupView {
     var _children: [any View] { children }
 }
@@ -123,6 +155,7 @@ public struct _ConditionalContent<TrueContent: View, FalseContent: View> {
     let storage: Storage
 }
 extension _ConditionalContent: _PrimitiveView {}
+extension _ConditionalContent: _TransparentGroup {}
 extension _ConditionalContent: _GroupView {
     var _children: [any View] {
         switch storage {
@@ -138,6 +171,7 @@ extension Optional: View where Wrapped: View {
 }
 // Unconditional: the marker only lets the trait lookups run (ViewTraits.swift).
 extension Optional: _TraitBearing {}
+extension Optional: _TransparentGroup where Wrapped: View {}
 extension Optional: _GroupView where Wrapped: View {
     var _children: [any View] {
         switch self {
@@ -155,6 +189,7 @@ public struct AnyView {
     public init<V: View>(erasing view: V) { storage = view }
 }
 extension AnyView: _PrimitiveView {}
+extension AnyView: _TransparentGroup {}
 extension AnyView: _GroupView {
     var _children: [any View] { [storage] }
 }
@@ -165,6 +200,7 @@ public struct Group<Content: View> {
     public init(@ViewBuilder content: () -> Content) { self.content = content() }
 }
 extension Group: _PrimitiveView {}
+extension Group: _TransparentGroup {}
 extension Group: _GroupView {
     var _children: [any View] { [content] }
 }

package/Sources/SwiftUI/Localization/Localization.swift

@@ -456,6 +456,28 @@ enum _LocalizedFormat {
         return pieces
     }
 
+    /// A formatted number's integer digits grouped with the locale's separator
+    /// and its decimal point the locale's, as Apple's localized formatting
+    /// (`String.localizedStringWithFormat`, which `Text` and
+    /// `String(localized:)` use) writes `%d`, `%u` and `%f`: `"\(1024)"` is
+    /// "1,024" in English (and a year "2,026", as on iOS).
+    static func localizedDigits(_ text: String) -> String {
+        let locale = Locale.current
+        let grouping = locale.groupingSeparator ?? ","
+        let decimal = locale.decimalSeparator ?? "."
+        guard let start = text.firstIndex(where: \.isNumber) else { return text }
+        let end = text[start...].firstIndex(where: { !$0.isNumber }) ?? text.endIndex
+        let digits = text[start..<end]
+        var grouped = ""
+        for (offset, digit) in digits.enumerated() {
+            if offset > 0 && (digits.count - offset) % 3 == 0 { grouped += grouping }
+            grouped.append(digit)
+        }
+        var rest = String(text[end...])
+        if rest.hasPrefix(".") { rest = decimal + rest.dropFirst() }
+        return String(text[..<start]) + grouped + rest
+    }
+
     /// One argument as its specifier formats it.
     static func render(_ argument: _LocalizationArgument, spec: String, conversion: Character) -> String {
         let flags = spec.filter { !"hlqLztj".contains($0) }
@@ -469,7 +491,7 @@ enum _LocalizedFormat {
             case .double(let v): v.isFinite ? Int64(v) : 0
             case .string(let v): Int64(v) ?? 0
             }
-            return flags.isEmpty ? String(value) : String(format: "%\(flags)lld", value)
+            return flags.isEmpty ? localizedDigits(String(value)) : String(format: "%\(flags)lld", value)
         case "u", "U", "x", "X", "o", "O":
             let value: UInt64 = switch argument {
             case .int(let v): UInt64(bitPattern: v)
@@ -479,6 +501,7 @@ enum _LocalizedFormat {
             }
             let lower = Character(conversion.lowercased())
             let code = lower == "u" ? "u" : String(conversion)
+            if lower == "u" && flags.isEmpty { return localizedDigits(String(value)) }
             return String(format: "%\(flags)ll\(code)", value)
         case "f", "F", "e", "E", "g", "G", "a", "A":
             let value: Double = switch argument {
@@ -487,7 +510,10 @@ enum _LocalizedFormat {
             case .double(let v): v
             case .string(let v): Double(v) ?? 0
             }
-            return String(format: "%\(flags)\(conversion)", value)
+            let text = String(format: "%\(flags)\(conversion)", value)
+            // A precision alone (`%.1f`) keeps the locale's digits; a width or a flag pads as given.
+            let plain = flags.isEmpty || flags.first == "." && flags.dropFirst().allSatisfy(\.isNumber)
+            return plain && (conversion == "f" || conversion == "F") ? localizedDigits(text) : text
         case "c", "C":
             if case .int(let v) = argument, let scalar = Unicode.Scalar(UInt32(truncatingIfNeeded: v)) { return String(Character(scalar)) }
             return argument.text

package/Sources/UIKit/ColorConversions.swift

@@ -36,7 +36,7 @@ extension UIColor {
     static let semanticColors: [String: UIColor] = {
         var colors: [String: UIColor] = ["primary": .label, "secondary": .secondaryLabel, "clear": .clear,
                                              // The app's accent color is the page's; system blue is its default.
-                                             "accent": UIColor(red: 0, green: 0.478, blue: 1, alpha: 1)]
+                                             "accent": UIColor(red: 0, green: 0.533, blue: 1, alpha: 1)]
         let named: [UIColor] = [
             .systemRed, .systemOrange, .systemYellow, .systemGreen, .systemMint, .systemTeal, .systemCyan, .systemBlue,
             .systemIndigo, .systemPurple, .systemPink, .systemBrown, .systemGray,

package/Sources/UIKit/UIKit.swift

@@ -145,8 +145,8 @@ public final class UIColor: Hashable, @unchecked Sendable {
     public static let secondaryLabel = named("secondaryLabel", 0.235, 0.235, 0.263, 0.6)
     public static let separator = named("separator", 0.235, 0.235, 0.263, 0.29)
     public static let systemGray = named("gray", 0.557, 0.557, 0.576)
-    public static let systemBlue = named("blue", 0, 0.478, 1)
-    public static let systemRed = named("red", 1, 0.231, 0.188)
+    public static let systemBlue = named("blue", 0, 0.533, 1)
+    public static let systemRed = named("red", 1, 0.22, 0.235)
     public static let systemGreen = named("green", 0.204, 0.78, 0.349)
     public static let tintColor = UIColor.systemBlue
 
@@ -167,15 +167,15 @@ public final class UIColor: Hashable, @unchecked Sendable {
     public static let systemGray4 = named("systemGray4", 0.82, 0.82, 0.839)
     public static let systemGray5 = named("systemGray5", 0.898, 0.898, 0.918)
     public static let systemGray6 = named("systemGray6", 0.949, 0.949, 0.969)
-    public static let systemOrange = named("orange", 1, 0.584, 0)
+    public static let systemOrange = named("orange", 1, 0.553, 0.157)
     public static let systemYellow = named("yellow", 1, 0.8, 0)
     public static let systemPink = named("pink", 1, 0.176, 0.333)
-    public static let systemPurple = named("purple", 0.686, 0.322, 0.871)
-    public static let systemTeal = named("teal", 0.188, 0.69, 0.78)
-    public static let systemIndigo = named("indigo", 0.345, 0.337, 0.839)
-    public static let systemMint = named("mint", 0, 0.78, 0.745)
-    public static let systemCyan = named("cyan", 0.196, 0.678, 0.902)
-    public static let systemBrown = named("brown", 0.635, 0.518, 0.369)
+    public static let systemPurple = named("purple", 0.796, 0.188, 0.878)
+    public static let systemTeal = named("teal", 0, 0.765, 0.816)
+    public static let systemIndigo = named("indigo", 0.38, 0.333, 0.961)
+    public static let systemMint = named("mint", 0, 0.784, 0.702)
+    public static let systemCyan = named("cyan", 0, 0.753, 0.91)
+    public static let systemBrown = named("brown", 0.675, 0.498, 0.369)
     public static let lightText = UIColor(white: 1, alpha: 0.6)
     public static let darkText = UIColor.black
 }

package/manifest.mjs

@@ -17,7 +17,9 @@ export function publishedManifest(rootManifest) {
   const lines = rootManifest.split('\n');
   const start = lines.findIndex((line) => line.startsWith('let package = Package('));
   if (start < 0) throw new Error('manifest.mjs: no `let package = Package(` in the root manifest');
-  const imports = lines.slice(0, start).filter((line) => line.startsWith('// swift-tools-version') || line.startsWith('import '));
+  const imports = lines
+    .slice(0, start)
+    .filter((line) => (line.startsWith('// swift-tools-version') || line.startsWith('import ')) && !line.trim().endsWith('// repository only'));
   const body = [];
   for (const line of lines.slice(start)) {
     const trimmed = line.trim();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@swiftbrowser/swift",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "The SwiftBrowser Swift package (the SwiftUI shim, Charts, SwiftData and FoundationBridge) as an npm package, so @swiftbrowser/cli builds apps against the exact version it ships with.",
   "repository": {
     "type": "git",