@swiftbrowser/swift 0.1.0 → 0.2.0

package/Sources/SwiftUI/API/LabelStyle.swift

@@ -94,7 +94,8 @@ extension EnvironmentValues {
     }
 }
 
-extension View {
+nonisolated extension View {
+    @MainActor
     public func labelStyle<S: LabelStyle>(_ style: S) -> some View {
         environment(\._labelStyle, _AnyLabelStyle(style))
     }
@@ -108,10 +109,16 @@ struct _StyledLabel: View {
     @Environment(\._labelStyle) private var style
 
     var body: some View {
-        let configuration = LabelStyleConfiguration(title: .init(view: title), icon: .init(view: icon))
-        if let style {
-            return AnyView(style.make(configuration))
-        }
-        return AnyView(DefaultLabelStyle().makeBody(configuration: configuration))
+        // The icon is marked so a list row can tint it (the title keeps the
+        // row's primary color), as iOS does for labels in lists.
+        let markedIcon = AnyView(icon)._styled { $0.extras["labelIcon"] = .bool(true) }
+        let configuration = LabelStyleConfiguration(title: .init(view: title), icon: .init(view: markedIcon))
+        let styled = style?.make(configuration) ?? DefaultLabelStyle().makeBody(configuration: configuration)
+        // As on iOS, the title stays the label's accessibility label when the
+        // style shows only the icon (a toolbar button), so an event script
+        // can name the button by it.
+        let titleText = _textContent(of: title)
+        if titleText.isEmpty { return AnyView(styled) }
+        return AnyView(AnyView(styled).accessibilityLabel(titleText))
     }
 }

package/Sources/SwiftUI/API/Layout.swift

@@ -10,7 +10,7 @@ public enum TextAlignment: Hashable, Sendable {
     }
 }
 
-extension View {
+nonisolated extension View {
     /// Sets the priority by which a parent stack hands out space.
     public func layoutPriority(_ value: Double) -> some View {
         _styled { $0.layoutPriority = value }
@@ -49,32 +49,62 @@ extension Color: _HostView {
 }
 
 /// A shape drawn as a view, optionally filled or stroked. `inset` strokes
-/// (`strokeBorder`) lie inside the shape's bounds.
+/// (`strokeBorder`) lie inside the shape's bounds. A custom shape (`"path"`)
+/// is drawn from its path (Shape.swift), with the fill rule and the whole
+/// stroke style; a built-in shape is drawn by name.
 public struct _ShapeView<S: Shape> {
     let shape: S
     let fill: (any ShapeStyle)?
     let stroke: (style: any ShapeStyle, lineWidth: CGFloat, inset: Bool)?
+    var eoFill = false
+    var strokeStyle: StrokeStyle? = nil
 }
 extension _ShapeView: _PrimitiveView {}
 extension _ShapeView: _HostView {
     var _kind: String { "shape" }
     func _props(in environment: EnvironmentValues) -> _JSON {
+        // A stroked shape filled with a style is its outline in that style.
+        if stroke == nil, let stroked = shape as? any _Stroked {
+            return stroked._outlineProps(style: fill ?? ForegroundStyle(), in: environment)
+        }
+        let drawsPath = shape._name == "path"
         var stroke: _JSON = .null
         if let s = self.stroke {
             var object: [String: _JSON] = ["color": s.style._json, "lineWidth": .number(s.lineWidth)]
-            if s.inset { object["inset"] = .bool(true) }
+            // A path is inset by the Swift side (Shape.swift); the page strokes it as is.
+            if s.inset && !drawsPath { object["inset"] = .bool(true) }
+            if drawsPath, let style = strokeStyle {
+                object["lineCap"] = .string(["butt", "round", "square"][Int(style.lineCap.rawValue)])
+                object["lineJoin"] = .string(["miter", "round", "bevel"][Int(style.lineJoin.rawValue)])
+                object["miterLimit"] = .number(style.miterLimit)
+                if !style.dash.isEmpty {
+                    object["dash"] = .array(style.dash.map(_JSON.number))
+                    object["dashPhase"] = .number(style.dashPhase)
+                }
+            }
             stroke = .object(object)
         }
-        return .object([
+        var props: [String: _JSON] = [
             "shape": .string(shape._name),
-            "cornerRadius": .number(shape._cornerRadius),
+            "cornerRadius": .number(_resolvedCornerRadius(shape, in: environment)),
             "fill": fill?._json ?? .null,
             "stroke": stroke,
-        ])
+        ]
+        if drawsPath {
+            // The page reports the size the path is drawn for; the runtime
+            // adds the path (`_pathProps`).
+            props["reportsSize"] = .bool(true)
+            if eoFill { props["fillRule"] = .string("evenodd") }
+        } else if let trimmed = shape as? _TrimmedShape {
+            // `.trim(from:to:)` of a built-in shape (ShapeTrim.swift); a path is trimmed itself.
+            props["trim"] = trimmed._trimJSON
+        }
+        return .object(props)
     }
 }
 
-/// Options for `fill`; accepted for source compatibility.
+/// How a shape is filled: `eoFill` uses the even-odd rule (a path's
+/// overlapping parts cancel out) rather than the non-zero winding rule.
 public struct FillStyle: Equatable, Sendable {
     public var isEOFilled: Bool
     public var isAntialiased: Bool
@@ -85,22 +115,25 @@ public struct FillStyle: Equatable, Sendable {
     }
 }
 
-extension Shape {
+nonisolated extension Shape {
     public func fill<S: ShapeStyle>(_ style: S, style fillStyle: FillStyle = FillStyle()) -> some View {
-        _ShapeView(shape: self, fill: style, stroke: nil)
+        _ShapeView(shape: self, fill: style, stroke: nil, eoFill: fillStyle.isEOFilled)
     }
 
     /// Filled with the foreground style.
     public func fill(style: FillStyle = FillStyle()) -> some View {
-        _ShapeView(shape: self, fill: ForegroundStyle(), stroke: nil)
+        _ShapeView(shape: self, fill: ForegroundStyle(), stroke: nil, eoFill: style.isEOFilled)
     }
 
     public func stroke<S: ShapeStyle>(_ style: S, lineWidth: CGFloat = 1) -> some View {
         _ShapeView(shape: self, fill: nil, stroke: (style, lineWidth, false))
     }
 
-    public func stroke(lineWidth: CGFloat = 1) -> some View {
-        _ShapeView(shape: self, fill: nil, stroke: (ForegroundStyle(), lineWidth, false))
+    /// The outline as a shape (iOS 17), so it can be filled or passed where a
+    /// shape goes (`.overlay(.bar, in: .capsule.stroke())`); as a view it is
+    /// the outline in the foreground style.
+    public func stroke(lineWidth: CGFloat = 1, antialiased: Bool = true) -> _StrokedShape<Self> {
+        _StrokedShape(base: self, lineWidth: lineWidth)
     }
 
     /// A stroke drawn inside the shape's bounds.
@@ -163,3 +196,25 @@ private func _shapeProps(_ shape: some Shape) -> _JSON {
         "stroke": .null,
     ])
 }
+
+/// A shape's outline as a shape (`shape.stroke(lineWidth:)`, iOS 17): drawn,
+/// or filled with a style, as the base shape stroked with that style.
+nonisolated public struct _StrokedShape<Base: Shape>: Shape {
+    let base: Base
+    let lineWidth: CGFloat
+
+    public var _name: String { base._name }
+    public var _cornerRadius: CGFloat { base._cornerRadius }
+    /// The base's path: a custom shape's outline is drawn from it.
+    public func path(in rect: CGRect) -> Path { base.path(in: rect) }
+}
+
+protocol _Stroked {
+    func _outlineProps(style: any ShapeStyle, in environment: EnvironmentValues) -> _JSON
+}
+
+extension _StrokedShape: _Stroked {
+    func _outlineProps(style: any ShapeStyle, in environment: EnvironmentValues) -> _JSON {
+        _ShapeView(shape: base, fill: nil, stroke: (style, lineWidth, false))._props(in: environment)
+    }
+}

package/Sources/SwiftUI/API/LazyStacks.swift

@@ -0,0 +1,49 @@
+// `LazyVStack` and `LazyHStack`: the same `vstack` / `hstack` elements as
+// `VStack` and `HStack`, whose `ForEach` rows are built as they come near the
+// visible area (Runtime/LazyRows.swift), as a `List`'s are.
+// `pinnedViews` is accepted: section headers and footers scroll with their
+// rows instead of sticking to the scroll view's edge.
+
+public struct LazyVStack<Content: View> {
+    let alignment: HorizontalAlignment
+    let spacing: CGFloat?
+    let content: Content
+
+    public init(alignment: HorizontalAlignment = .center, spacing: CGFloat? = nil,
+                pinnedViews: PinnedScrollableViews = .init(), @ViewBuilder content: () -> Content) {
+        self.alignment = alignment
+        self.spacing = spacing
+        self.content = content()
+    }
+}
+extension LazyVStack: _PrimitiveView {}
+extension LazyVStack: _HostView {
+    var _kind: String { "vstack" }
+    func _props(in environment: EnvironmentValues) -> _JSON {
+        .object(["spacing": spacing.map(_JSON.number) ?? .null, "alignment": .string(alignment.name)])
+    }
+    var _content: [any View] { [content] }
+}
+extension LazyVStack: _ScrollTargetContainer {}
+
+public struct LazyHStack<Content: View> {
+    let alignment: VerticalAlignment
+    let spacing: CGFloat?
+    let content: Content
+
+    public init(alignment: VerticalAlignment = .center, spacing: CGFloat? = nil,
+                pinnedViews: PinnedScrollableViews = .init(), @ViewBuilder content: () -> Content) {
+        self.alignment = alignment
+        self.spacing = spacing
+        self.content = content()
+    }
+}
+extension LazyHStack: _PrimitiveView {}
+extension LazyHStack: _HostView {
+    var _kind: String { "hstack" }
+    func _props(in environment: EnvironmentValues) -> _JSON {
+        .object(["spacing": spacing.map(_JSON.number) ?? .null, "alignment": .string(alignment.name)])
+    }
+    var _content: [any View] { [content] }
+}
+extension LazyHStack: _ScrollTargetContainer {}

package/Sources/SwiftUI/API/LegacyAlert.swift

@@ -0,0 +1,97 @@
+// SwiftUI's first alert API, still common in packages: `Alert` values with
+// `Alert.Button`s, shown by `.alert(isPresented:content:)` or
+// `.alert(item:content:)`, and `@Environment(\.presentationMode)`. An
+// `Alert` becomes the same `alert` element as the newer `.alert(_:isPresented:
+// actions:message:)` (Alert.swift): each button is a `Button` with its role.
+
+/// An alert: a title, an optional message and up to two buttons.
+public struct Alert {
+    let title: Text
+    let message: Text?
+    let buttons: [Button]
+
+    public init(title: Text, message: Text? = nil, dismissButton: Button? = nil) {
+        self.title = title
+        self.message = message
+        buttons = dismissButton.map { [$0] } ?? []
+    }
+
+    public init(title: Text, message: Text? = nil, primaryButton: Button, secondaryButton: Button) {
+        self.title = title
+        self.message = message
+        buttons = [primaryButton, secondaryButton]
+    }
+
+    /// An alert button: a label, a role and an action.
+    public struct Button {
+        let label: Text
+        let role: ButtonRole?
+        let action: (() -> Void)?
+
+        public static func `default`(_ label: Text, action: (() -> Void)? = {}) -> Button {
+            Button(label: label, role: nil, action: action)
+        }
+
+        public static func cancel(_ label: Text, action: (() -> Void)? = {}) -> Button {
+            Button(label: label, role: .cancel, action: action)
+        }
+
+        /// "Cancel".
+        public static func cancel(_ action: (() -> Void)? = {}) -> Button {
+            Button(label: Text("Cancel"), role: .cancel, action: action)
+        }
+
+        public static func destructive(_ label: Text, action: (() -> Void)? = {}) -> Button {
+            Button(label: label, role: .destructive, action: action)
+        }
+    }
+
+    /// The buttons as views; "OK" when the alert has none, as SwiftUI shows.
+    @MainActor var actions: [SwiftUI.Button<Text>] {
+        let buttons = self.buttons.isEmpty ? [Button.default(Text("OK"))] : self.buttons
+        return buttons.map { button in
+            let action = button.action
+            return SwiftUI.Button(role: button.role, action: { action?() }) { button.label }
+        }
+    }
+}
+
+extension View {
+    /// Shows the alert `content` makes while `isPresented` is true.
+    public func alert(isPresented: Binding<Bool>, content: () -> Alert) -> some View {
+        let alert = content()
+        return _AlertView(base: self, isPresented: isPresented, title: alert.title.content,
+                          message: alert.message?.content, style: "alert",
+                          actions: ForEach(Array(alert.actions.enumerated()), id: \.offset) { $0.element })
+    }
+
+    /// Shows the alert `content` makes from `item` while it is non-nil;
+    /// dismissing sets it back to nil.
+    public func alert<Item: Identifiable>(item: Binding<Item?>, content: (Item) -> Alert) -> some View {
+        let presented = Binding(get: { item.wrappedValue != nil }, set: { if !$0 { item.wrappedValue = nil } })
+        let alert = item.wrappedValue.map(content) ?? Alert(title: Text(""))
+        return _AlertView(base: self, isPresented: presented, title: alert.title.content,
+                          message: alert.message?.content, style: "alert",
+                          actions: ForEach(Array(alert.actions.enumerated()), id: \.offset) { $0.element })
+    }
+}
+
+// MARK: - Presentation mode
+
+/// Whether the view is presented, and how to dismiss it: `dismiss()` is the
+/// environment's `dismiss` action.
+public struct PresentationMode {
+    let dismissAction: DismissAction
+
+    /// True: the shim does not track this for the view.
+    public var isPresented: Bool { true }
+
+    @MainActor public mutating func dismiss() { dismissAction() }
+}
+
+extension EnvironmentValues {
+    public var presentationMode: Binding<PresentationMode> {
+        let mode = PresentationMode(dismissAction: dismiss)
+        return Binding(get: { mode }, set: { _ in })
+    }
+}

package/Sources/SwiftUI/API/Lists.swift

@@ -32,7 +32,7 @@ extension ListStyle where Self == GroupedListStyle {
     public static var grouped: GroupedListStyle { GroupedListStyle() }
 }
 
-extension View {
+nonisolated extension View {
     public func listStyle<S: ListStyle>(_ style: S) -> some View {
         environment(\._listStyle, style._name)
     }
@@ -53,6 +53,12 @@ struct _ListSelection {
     let accepts: (AnyHashable) -> Bool
     /// `Set<Value>` selections toggle on tap; `Value?` selections set.
     let isMultiple: Bool
+    /// The whole current selection, for the identity below.
+    let snapshot: () -> AnyHashable
+    /// Set by the runtime: the list and the selection the pass carried, so the
+    /// environments of two passes compare equal while the selection is unchanged
+    /// (the binding is re-created by every pass; see `_Sameness`).
+    var identity: _RuntimeKey?
 
     init<Value: Hashable>(_ binding: Binding<Value?>) {
         get = { binding.wrappedValue.map { AnyHashable($0) } }
@@ -67,6 +73,7 @@ struct _ListSelection {
         }
         accepts = { $0.base is Value }
         isMultiple = false
+        snapshot = { AnyHashable(binding.wrappedValue) }
     }
 
     /// `get` / `set` reduce a multiple selection to one value: the first of the set.
@@ -93,11 +100,12 @@ struct _ListSelection {
         }
         accepts = { $0.base is Value }
         isMultiple = true
+        snapshot = { AnyHashable(binding.wrappedValue) }
     }
 }
 
 /// Lists that carry a selection binding; the runtime puts it in the rows' environment.
-protocol _ListSelectionProviding {
+protocol _ListSelectionProviding: _TraitBearing {
     var _selection: _ListSelection? { get }
 }
 
@@ -198,6 +206,12 @@ extension List: _HostView {
         var props: [String: _JSON] = ["style": .string(environment._listStyle)]
         if environment.editMode?.wrappedValue.isEditing == true { props["editing"] = .bool(true) }
         _refresh(in: environment).addProps(to: &props)
+        // `.scrollDismissesKeyboard` (ScrollModifiers.swift).
+        if environment._scrollDismissesKeyboard { props["dismissesKeyboard"] = .bool(true) }
+        // `.scrollContentBackground(.hidden)` (ScrollViewReader.swift).
+        if environment._scrollContentBackground == .hidden { props["background"] = .string("hidden") }
+        // `.environment(\.defaultMinListRowHeight, 1)`: rows as short as their content.
+        if environment.defaultMinListRowHeight != 44 { props["minRowHeight"] = .number(Double(max(0, environment.defaultMinListRowHeight))) }
         return .object(props)
     }
     var _content: [any View] { [content] }
@@ -211,7 +225,7 @@ extension List: _Refreshing {}
 
 /// `List` and `ScrollView`: hosts whose `refresh` handler the runtime takes
 /// from `_refresh(in:)` (the handler depends on the environment).
-protocol _Refreshing {
+protocol _Refreshing: _TraitBearing {
     func _refresh(in environment: EnvironmentValues) -> _Refresh
 }
 extension List: _ListSelectionProviding {
@@ -224,6 +238,10 @@ public struct Section<Content: View> {
     let header: String?
     let footer: String?
     let content: Content
+    /// Modifiers applied to the section itself (`Section { … }.disabled(x)`)
+    /// style each of its rows, as in SwiftUI, instead of boxing the section
+    /// (a `styled` around a `section` is not a section to the list layout).
+    var rowStyles: [_Style] = []
 
     public init(@ViewBuilder content: () -> Content) {
         self.header = nil
@@ -231,6 +249,14 @@ public struct Section<Content: View> {
         self.content = content()
     }
 
+    /// A header from a localized key.
+    public init(_ titleKey: LocalizedStringKey, @ViewBuilder content: () -> Content) {
+        self.header = titleKey.key
+        self.footer = nil
+        self.content = content()
+    }
+
+    @_disfavoredOverload
     public init<S: StringProtocol>(_ title: S, @ViewBuilder content: () -> Content) {
         self.header = String(title)
         self.footer = nil
@@ -256,14 +282,27 @@ public struct Section<Content: View> {
         self.footer = footer().content
         self.content = content()
     }
+
+    /// A header or footer that is a `Text` (or an optional one) is a string
+    /// prop, as above; any other view is a `sectionheader` / `sectionfooter`
+    /// child (SectionSupplements.swift).
+    var headerView: (any View)?
+    var footerView: (any View)?
 }
-/// Lets pickers look through sections for their options.
-protocol _SectionView {
+/// Lets pickers look through sections for their options, and modifiers
+/// style a section's rows.
+protocol _SectionView: _TraitBearing {
     var _sectionContent: any View { get }
+    func _stylingRows(_ style: _Style) -> any View
 }
 
 extension Section: _SectionView {
     var _sectionContent: any View { content }
+    func _stylingRows(_ style: _Style) -> any View {
+        var copy = self
+        copy.rowStyles.append(style)
+        return copy
+    }
 }
 
 extension Section: _PrimitiveView {}
@@ -272,5 +311,21 @@ extension Section: _HostView {
     func _props(in environment: EnvironmentValues) -> _JSON {
         .object(["header": header.map(_JSON.string) ?? .null, "footer": footer.map(_JSON.string) ?? .null])
     }
-    var _content: [any View] { [content] }
+    var _content: [any View] {
+        // Each style distributes over the rows (`_StyledGroup`); a second one
+        // wraps the already styled rows again.
+        var view: any View = content
+        for style in rowStyles { view = _styledGroup(view, style) }
+        // View headers and footers come first and last, outside the row styles.
+        var children: [any View] = [view]
+        if let headerView { children.insert(_SectionSupplement(kind: "sectionheader", content: headerView), at: 0) }
+        if let footerView { children.append(_SectionSupplement(kind: "sectionfooter", content: footerView)) }
+        return children
+    }
+}
+
+/// `_StyledGroup(content: view, style: style)` for an existential view.
+func _styledGroup(_ view: any View, _ style: _Style) -> any View {
+    func open<V: View>(_ content: V) -> any View { _StyledGroup(content: content, style: style) }
+    return open(view)
 }

package/Sources/SwiftUI/API/Menu.swift

@@ -13,6 +13,7 @@ public struct Menu<Label: View, Content: View> {
 }
 
 extension Menu where Label == Text {
+    @_disfavoredOverload
     public init<S: StringProtocol>(_ title: S, @ViewBuilder content: () -> Content) {
         self.label = Text(title)
         self.content = content()
@@ -20,6 +21,7 @@ extension Menu where Label == Text {
 }
 
 extension Menu where Label == SwiftUI.Label<Text, Image> {
+    @_disfavoredOverload
     public init<S: StringProtocol>(_ title: S, systemImage: String, @ViewBuilder content: () -> Content) {
         self.label = SwiftUI.Label(String(title), systemImage: systemImage)
         self.content = content()
@@ -39,13 +41,18 @@ public struct ButtonMenuStyle: MenuStyle { public init() {} }
 extension MenuStyle where Self == DefaultMenuStyle {
     public static var automatic: DefaultMenuStyle { DefaultMenuStyle() }
 }
+/// A menu whose label is a borderless button (iOS 14's style, deprecated); drawn as the default.
+public struct BorderlessButtonMenuStyle: MenuStyle { public init() {} }
+extension MenuStyle where Self == BorderlessButtonMenuStyle {
+    public static var borderlessButton: BorderlessButtonMenuStyle { BorderlessButtonMenuStyle() }
+}
 extension MenuStyle where Self == ButtonMenuStyle {
     public static var button: ButtonMenuStyle { ButtonMenuStyle() }
 }
 
 public enum MenuIndicatorVisibility: Hashable, Sendable { case automatic, visible, hidden }
 
-extension View {
+nonisolated extension View {
     public func menuStyle<S: MenuStyle>(_ style: S) -> some View { self }
     public func menuIndicator(_ visibility: MenuIndicatorVisibility) -> some View { self }
 }

package/Sources/SwiftUI/API/Modifiers.swift

@@ -37,6 +37,10 @@ struct _Style: Equatable {
     var background: (any ShapeStyle)?
     var frame: Frame?
     var cornerRadius: CGFloat?
+    /// `.clipShape(.containerRelative)`: clipped to the container's corners.
+    var clipsToContainerShape = false
+    /// `.background(_:)`: painted in the container's shape (`.containerShape`).
+    var backgroundInContainerShape = false
     var opacity: Double?
     var disabled: Bool?
     var layoutPriority: Double?
@@ -88,9 +92,31 @@ public struct _StyledView<Content: View> {
     let style: _Style
 }
 extension _StyledView: _PrimitiveView {}
+extension _StyledView: _EnvironmentModifying {
+    /// A font with a text style or a size is the environment's `font` below
+    /// (a weight or design alone changes the font the page draws, not that).
+    func _apply(to environment: inout EnvironmentValues) {
+        if let font = style.font, font.textStyle != nil || font.size != nil { environment.font = font }
+    }
+}
 extension _StyledView: _HostView {
     var _kind: String { "styled" }
-    func _props(in environment: EnvironmentValues) -> _JSON { .object(["style": style._json]) }
+    func _props(in environment: EnvironmentValues) -> _JSON {
+        var resolved = style
+        // `.background()` paints the background style in context, which
+        // `.backgroundStyle(_:)` sets (the system background by default).
+        if style.background is BackgroundStyle, let contextual = environment._backgroundStyle {
+            resolved.background = contextual
+        }
+        // The container's shape (`.containerShape`): a background is painted
+        // in it, and `.clipShape(.containerRelative)` clips to it.
+        let container = environment._containerShapeRadius
+        if style.clipsToContainerShape { resolved.cornerRadius = container ?? 0 }
+        if style.backgroundInContainerShape, let container, container > 0 {
+            resolved.extras["backgroundCornerRadius"] = .number(container)
+        }
+        return .object(["style": resolved._json])
+    }
     var _content: [any View] { [content] }
 }
 
@@ -104,21 +130,34 @@ public struct _StyledGroup<Content: View> {
 extension _StyledGroup: _PrimitiveView {}
 extension _StyledGroup: _GroupView {
     var _children: [any View] {
-        if let group = content as? any _GroupView, group._children.count != 1 || group._keys != nil {
+        // A modifier on a `Section` styles its rows (the section stays a direct
+        // 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) }
         }
         return [_StyledView(content: content, style: style)]
     }
 
     var _keys: [AnyHashable]? {
-        if let group = content as? any _GroupView, group._children.count != 1 || group._keys != nil {
+        if let group = content as? any _GroupView, group._spreads {
             return group._keys
         }
         return nil
     }
+
+    // Asked of the content alone: a chain of modifiers asks each level once,
+    // where computing the content's children and keys at every level made
+    // the cost double with each modifier.
+    var _spreads: Bool {
+        guard let group = content as? any _GroupView, group._spreads else { return false }
+        // A styled section is one child; it keeps the section's keys.
+        if content is any _SectionView { return group._keys != nil }
+        return true
+    }
 }
 
-extension View {
+nonisolated extension View {
     func _styled(_ configure: (inout _Style) -> Void) -> _StyledGroup<Self> {
         var style = _Style()
         configure(&style)
@@ -139,6 +178,16 @@ extension View {
         }
     }
 
+    /// The padding a scene's content takes from its edges: 16 points on
+    /// iPhone, as `.padding()`.
+    public func scenePadding(_ edges: Edge.Set = .all) -> some View {
+        padding(edges, 16)
+    }
+
+    public func scenePadding(_ padding: ScenePadding, edges: Edge.Set = .all) -> some View {
+        self.padding(edges, 16)
+    }
+
     public func padding(_ length: CGFloat) -> some View {
         padding(.all, length)
     }
@@ -182,13 +231,20 @@ extension View {
     }
 
     /// A paint behind the view: a color, gradient or material filling its box.
+    /// Painted in the container's shape (`.containerShape`), else the box, as in SwiftUI.
     public func background<S: ShapeStyle>(_ style: S, ignoresSafeAreaEdges edges: Edge.Set = .all) -> some View {
-        _styled { $0.background = style }
+        _styled {
+            $0.background = style
+            $0.backgroundInContainerShape = true
+        }
     }
 
     /// The system background color behind the view.
     public func background(ignoresSafeAreaEdges edges: Edge.Set = .all) -> some View {
-        _styled { $0.background = BackgroundStyle() }
+        _styled {
+            $0.background = BackgroundStyle()
+            $0.backgroundInContainerShape = true
+        }
     }
 
     public func opacity(_ opacity: Double) -> some View {
@@ -227,10 +283,15 @@ extension View {
 
     public func scaledToFill() -> some View { aspectRatio(nil, contentMode: .fill) }
 
-    /// Identity and compositing hints; accepted for source compatibility and
-    /// currently without effect on the rendered tree.
-    public func id<ID: Hashable>(_ id: ID) -> some View { self }
+    /// Names the view for `ScrollViewProxy.scrollTo(_:anchor:)` inside a
+    /// `ScrollViewReader` (ScrollViewReader.swift); elsewhere it adds nothing
+    /// to the rendered tree. A changed id does not reset the view's state.
+    public func id<ID: Hashable>(_ id: ID) -> some View {
+        _IdentifiedView(content: self, id: AnyHashable(id))
+    }
 
+    /// A compositing hint; accepted for source compatibility and currently
+    /// without effect on the rendered tree.
     public func compositingGroup() -> some View { self }
 
     public func cornerRadius(_ radius: CGFloat, antialiased: Bool = true) -> some View {
@@ -238,6 +299,15 @@ extension View {
     }
 
     public func clipShape<S: Shape>(_ shape: S) -> some View {
-        _styled { $0.cornerRadius = shape._cornerRadius }
+        _styled {
+            $0.cornerRadius = shape._cornerRadius
+            $0.clipsToContainerShape = shape is ContainerRelativeShape
+        }
     }
 }
+
+/// The kind of scene padding (`.minimum`); iPhone has one.
+public struct ScenePadding: Equatable, Sendable {
+    public static let minimum = ScenePadding()
+    public static let navigationBar = ScenePadding()
+}