@swiftbrowser/swift 0.1.0 → 0.2.0

package/Sources/SwiftUI/API/ContainerBackground.swift

@@ -0,0 +1,28 @@
+// `.containerBackground(for:)` (iOS 17): a background for the container a
+// view is placed in (a navigation stack, a widget, StoreKit's subscription
+// store). The browser draws it behind the view itself, which is where it
+// shows for a view that fills its container.
+
+/// Where a container background goes. Frameworks add their own placements
+/// (StoreKit's `.subscriptionStore`) through `init(_name:)`.
+public struct ContainerBackgroundPlacement: Hashable, Sendable {
+    public let _name: String
+    public init(_name: String) { self._name = _name }
+
+    public static let navigation = ContainerBackgroundPlacement(_name: "navigation")
+    public static let navigationSplitView = ContainerBackgroundPlacement(_name: "navigationSplitView")
+    public static let tabView = ContainerBackgroundPlacement(_name: "tabView")
+    public static let widget = ContainerBackgroundPlacement(_name: "widget")
+}
+
+extension View {
+    /// Draws `content` behind the view.
+    public func containerBackground<V: View>(for container: ContainerBackgroundPlacement, alignment: Alignment = .center, @ViewBuilder content: () -> V) -> some View {
+        background(alignment: alignment, content: content)
+    }
+
+    /// Fills the area behind the view with `style`.
+    public func containerBackground<S: ShapeStyle>(_ style: S, for container: ContainerBackgroundPlacement) -> some View {
+        background(style)
+    }
+}

package/Sources/SwiftUI/API/ContentShape.swift

@@ -0,0 +1,33 @@
+// `.contentShape(_:)`: on iOS it makes the whole shape hit-testable (a tap
+// on the gap of an `HStack` with a `Spacer` reaches its gesture). On the page
+// every element's hit area is already its whole box, so the modifier is
+// accepted without adding to the tree; a non-rectangular shape (`Circle()`)
+// still hits as its bounding box (an approximation).
+
+public struct ContentShapeKinds: OptionSet, Hashable, Sendable {
+    public let rawValue: Int
+    public init(rawValue: Int) { self.rawValue = rawValue }
+    public static let interaction = ContentShapeKinds(rawValue: 1 << 0)
+    public static let dragPreview = ContentShapeKinds(rawValue: 1 << 1)
+    public static let contextMenuPreview = ContentShapeKinds(rawValue: 1 << 2)
+    public static let hoverEffect = ContentShapeKinds(rawValue: 1 << 3)
+    public static let focusEffect = ContentShapeKinds(rawValue: 1 << 4)
+    public static let accessibility = ContentShapeKinds(rawValue: 1 << 5)
+}
+
+nonisolated extension View {
+    public func contentShape<S: Shape>(_ shape: S, eoFill: Bool = false) -> some View { self }
+
+    public func contentShape<S: Shape>(_ kind: ContentShapeKinds, _ shape: S, eoFill: Bool = false) -> some View { self }
+}
+
+nonisolated extension View {
+    /// The iOS 17 tap with its location: the point in the view's own
+    /// coordinates, which the page sends with the tap (a named or global
+    /// space gets the local point too). `count` is ignored as for
+    /// `onTapGesture(count:perform:)`.
+    public func onTapGesture(count: Int = 1, coordinateSpace: CoordinateSpace = .local,
+                             perform action: @escaping @MainActor (CGPoint) -> Void) -> some View {
+        _TapGestureView(content: self, locatedAction: action)
+    }
+}

package/Sources/SwiftUI/API/ContentSizeCategory.swift

@@ -0,0 +1,35 @@
+// `ContentSizeCategory` and `EnvironmentValues.sizeCategory`: SwiftUI's
+// Dynamic Type sizes before `DynamicTypeSize` (iOS 15), still read by UIKit
+// code that scales its fonts (Ice Cubes' composer). The value is the
+// environment's `dynamicTypeSize` under its old names.
+
+/// A Dynamic Type size, by its pre-iOS 15 name.
+public enum ContentSizeCategory: Hashable, CaseIterable, Sendable {
+    case extraSmall, small, medium, large, extraLarge, extraExtraLarge, extraExtraExtraLarge
+    case accessibilityMedium, accessibilityLarge, accessibilityExtraLarge
+    case accessibilityExtraExtraLarge, accessibilityExtraExtraExtraLarge
+
+    public var isAccessibilityCategory: Bool { DynamicTypeSize(self).isAccessibilitySize }
+}
+
+extension DynamicTypeSize {
+    /// The size a `ContentSizeCategory` names.
+    public init(_ category: ContentSizeCategory) {
+        self = DynamicTypeSize.allCases[ContentSizeCategory.allCases.firstIndex(of: category) ?? 3]
+    }
+}
+
+extension ContentSizeCategory {
+    /// The category of a `DynamicTypeSize`.
+    public init(_ size: DynamicTypeSize) {
+        self = ContentSizeCategory.allCases[size.rawValue]
+    }
+}
+
+extension EnvironmentValues {
+    /// `dynamicTypeSize` as a `ContentSizeCategory`.
+    public var sizeCategory: ContentSizeCategory {
+        get { ContentSizeCategory(dynamicTypeSize) }
+        set { dynamicTypeSize = DynamicTypeSize(newValue) }
+    }
+}

package/Sources/SwiftUI/API/ContentUnavailable.swift

@@ -0,0 +1,101 @@
+// `ContentUnavailableView`: the centered icon, title, description and
+// actions iOS shows for an empty or failed state, built from the shim's
+// own views (a large secondary icon over a bold title, a secondary
+// description, then the actions), filling the space it is given.
+
+public struct ContentUnavailableView<Label: View, Description: View, Actions: View>: View {
+    let label: Label
+    let description: Description
+    let actions: Actions
+
+    public init(@ViewBuilder label: () -> Label,
+                @ViewBuilder description: () -> Description = { EmptyView() },
+                @ViewBuilder actions: () -> Actions = { EmptyView() }) {
+        self.label = label()
+        self.description = description()
+        self.actions = actions()
+    }
+
+    public var body: some View {
+        VStack(spacing: 16) {
+            VStack(spacing: 8) {
+                label.labelStyle(_ContentUnavailableLabelStyle())
+                description
+                    .font(.callout)
+                    .foregroundStyle(.secondary)
+                    .multilineTextAlignment(.center)
+            }
+            actions
+        }
+        .padding(.horizontal, 32)
+        .frame(maxWidth: .infinity, maxHeight: .infinity)
+    }
+}
+
+extension ContentUnavailableView where Label == SwiftUI.Label<Text, Image>, Description == Text?, Actions == EmptyView {
+    public init(_ titleKey: LocalizedStringKey, systemImage name: String, description: Text? = nil) {
+        self.init(label: { SwiftUI.Label(titleKey, systemImage: name) }, description: { description })
+    }
+
+    public init(_ titleKey: LocalizedStringKey, image name: String, description: Text? = nil) {
+        self.init(label: { SwiftUI.Label(Text(titleKey).content, image: name) }, description: { description })
+    }
+
+    @_disfavoredOverload
+    public init<S: StringProtocol>(_ title: S, systemImage name: String, description: Text? = nil) {
+        self.init(label: { SwiftUI.Label(title, systemImage: name) }, description: { description })
+    }
+
+    @_disfavoredOverload
+    public init<S: StringProtocol>(_ title: S, image name: String, description: Text? = nil) {
+        self.init(label: { SwiftUI.Label(title, image: name) }, description: { description })
+    }
+}
+
+/// The content of `ContentUnavailableView.search`.
+public enum SearchUnavailableContent {
+    public struct Label: View {
+        let text: String?
+        public var body: some View {
+            SwiftUI.Label(text.map { "No Results for \u{201C}\($0)\u{201D}" } ?? "No Results", systemImage: "magnifyingglass")
+        }
+    }
+
+    public struct Description: View {
+        public var body: some View { Text("Check the spelling or try a new search.") }
+    }
+
+    public struct Actions: View {
+        public var body: some View { EmptyView() }
+    }
+}
+
+extension ContentUnavailableView where Label == SearchUnavailableContent.Label,
+                                       Description == SearchUnavailableContent.Description,
+                                       Actions == SearchUnavailableContent.Actions {
+    /// "No Results" for a search.
+    public static var search: ContentUnavailableView { search(nil) }
+
+    /// "No Results for “text”" for a search.
+    public static func search(text: String) -> ContentUnavailableView { search(text) }
+
+    private static func search(_ text: String?) -> ContentUnavailableView {
+        ContentUnavailableView(label: { SearchUnavailableContent.Label(text: text) },
+                               description: { SearchUnavailableContent.Description() },
+                               actions: { SearchUnavailableContent.Actions() })
+    }
+}
+
+/// The icon large and secondary above a bold title.
+struct _ContentUnavailableLabelStyle: LabelStyle {
+    func makeBody(configuration: Configuration) -> some View {
+        VStack(spacing: 12) {
+            configuration.icon
+                .font(.system(size: 48))
+                .foregroundStyle(.secondary)
+            configuration.title
+                .font(.title2.bold())
+                .multilineTextAlignment(.center)
+        }
+    }
+}

package/Sources/SwiftUI/API/Controls.swift

@@ -1,3 +1,5 @@
+import Foundation
+
 // MARK: - TextField
 
 public protocol TextFieldStyle {
@@ -25,21 +27,12 @@ extension TextFieldStyle where Self == RoundedBorderTextFieldStyle {
     public static var roundedBorder: RoundedBorderTextFieldStyle { RoundedBorderTextFieldStyle() }
 }
 
-extension View {
+nonisolated extension View {
     public func textFieldStyle<S: TextFieldStyle>(_ style: S) -> some View {
         environment(\._textFieldStyle, style._name)
     }
 }
 
-/// Formats a value as text and parses text back (`Text(_:format:)`,
-/// `TextField(_:value:format:)`). `FoundationLite` conforms its format styles
-/// (`.number`, `.currency(code:)`); the shim itself has none.
-public protocol _TextFormat {
-    associatedtype Input
-    func _formatText(_ value: Input) -> String
-    func _parseText(_ text: String) -> Input?
-}
-
 /// What the user typed into a formatted field, and the formatted form of the
 /// value it parsed to. The field shows the typed text while the bound value
 /// still formats to that form; an outside change to the value replaces it.
@@ -55,6 +48,11 @@ public struct TextField<Label: View> {
     /// Persistent storage for `TextField(_:value:format:)` (unused otherwise);
     /// a `State` so the runtime keeps it across re-renders.
     let draft: State<_TextDraft?>
+    /// `TextField(_:text:axis: .vertical)`: a multi-line field that grows
+    /// with its text (TextFieldAxis.swift).
+    var axis: Axis = .horizontal
+    /// The iOS 13 `onCommit:` action (TextFieldCommit.swift): run on Return, like `.onSubmit`.
+    var onCommit: (() -> Void)?
 
     init(placeholder: String, text: Binding<String>, secure: Bool) {
         self.placeholder = placeholder
@@ -65,11 +63,13 @@ public struct TextField<Label: View> {
 }
 
 extension TextField where Label == Text {
+    @_disfavoredOverload
     public init<S: StringProtocol>(_ title: S, text: Binding<String>) {
         self.init(placeholder: String(title), text: text, secure: false)
     }
 
     /// The prompt, when given, is the placeholder; the title names the field.
+    @_disfavoredOverload
     public init<S: StringProtocol>(_ title: S, text: Binding<String>, prompt: Text?) {
         self.init(placeholder: prompt?.content ?? String(title), text: text, secure: false)
     }
@@ -81,34 +81,32 @@ extension TextField where Label == Text {
     /// A field bound to a value through a format: it shows the formatted value
     /// and, as the user types, parses the text and sets the value when parsing
     /// succeeds. The typed text stays visible while the value matches it.
-    public init<S: StringProtocol, F: _TextFormat>(_ title: S, value: Binding<F.Input>, format: F,
-                                                   prompt: Text? = nil) {
-        self.init(_placeholder: prompt?.content ?? String(title), value: value, format: format)
+    public init<S: StringProtocol, F: ParseableFormatStyle>(_ title: S, value: Binding<F.FormatInput>, format: F, prompt: Text? = nil)
+    where F.FormatOutput == String, F.Strategy.ParseInput == String {
+        self.init(placeholder: prompt?.content ?? String(title), value: value, format: format)
     }
 
-    public init<F: _TextFormat>(_ titleKey: LocalizedStringKey, value: Binding<F.Input>, format: F,
-                                prompt: Text? = nil) {
-        self.init(_placeholder: prompt?.content ?? titleKey.key, value: value, format: format)
+    public init<F: ParseableFormatStyle>(_ titleKey: LocalizedStringKey, value: Binding<F.FormatInput>, format: F, prompt: Text? = nil)
+    where F.FormatOutput == String, F.Strategy.ParseInput == String {
+        self.init(placeholder: prompt?.content ?? titleKey.key, value: value, format: format)
     }
 
-    /// The formatted field with its placeholder resolved; public so a bridge
-    /// module can wrap other format protocols (FoundationBridge wraps
-    /// Foundation's `ParseableFormatStyle`) without re-entering the public
-    /// initializers above.
-    public init<F: _TextFormat>(_placeholder placeholder: String, value: Binding<F.Input>, format: F) {
+    /// The formatted field with its placeholder resolved.
+    init<F: ParseableFormatStyle>(placeholder: String, value: Binding<F.FormatInput>, format: F)
+    where F.FormatOutput == String, F.Strategy.ParseInput == String {
         let draft = State<_TextDraft?>(wrappedValue: nil)
         let text = Binding<String>(
             get: {
-                let formatted = format._formatText(value.wrappedValue)
+                let formatted = format.format(value.wrappedValue)
                 if let current = draft.wrappedValue, current.formatted == formatted { return current.typed }
                 return formatted
             },
             set: { typed in
-                if let parsed = format._parseText(typed) {
-                    draft.wrappedValue = _TextDraft(typed: typed, formatted: format._formatText(parsed))
+                if let parsed = try? format.parseStrategy.parse(typed) {
+                    draft.wrappedValue = _TextDraft(typed: typed, formatted: format.format(parsed))
                     value.wrappedValue = parsed
                 } else {
-                    let formatted = draft.wrappedValue?.formatted ?? format._formatText(value.wrappedValue)
+                    let formatted = draft.wrappedValue?.formatted ?? format.format(value.wrappedValue)
                     draft.wrappedValue = _TextDraft(typed: typed, formatted: formatted)
                 }
             }
@@ -132,8 +130,9 @@ extension TextField: _HostView {
         // Phase 12: `.focused(...)` binds the field's focus; `.onSubmit` wants
         // the Enter key; `.submitLabel` names the return key.
         if let focus = environment._focus { props["focused"] = .bool(focus.isFocused()) }
-        if environment._onSubmit != nil { props["submit"] = .bool(true) }
+        if environment._onSubmit != nil || onCommit != nil { props["submit"] = .bool(true) }
         if let label = environment._submitLabel { props["submitLabel"] = .string(label) }
+        if axis == .vertical { props["axis"] = .string("vertical") }
         return .object(props)
     }
     var _handler: ((_JSON) -> Void)? { _handler(in: EnvironmentValues()) }
@@ -144,6 +143,7 @@ extension TextField: _EnvironmentHandling {
         let text = self.text
         let focus = environment._focus
         let onSubmit = environment._onSubmit
+        let onCommit = self.onCommit
         return { payload in
             switch payload {
             case .string(let value):
@@ -153,6 +153,7 @@ extension TextField: _EnvironmentHandling {
                 case .string("focus")?:
                     if case .bool(let focused)? = fields["value"] { focus?.setFocused(focused) }
                 case .string("submit")?:
+                    onCommit?()
                     onSubmit?()
                 default:
                     break
@@ -168,6 +169,11 @@ public struct SecureField<Label: View> {
     let field: TextField<Label>
 }
 extension SecureField where Label == Text {
+    public init(_ titleKey: LocalizedStringKey, text: Binding<String>) {
+        field = TextField(placeholder: titleKey.key, text: text, secure: true)
+    }
+
+    @_disfavoredOverload
     public init<S: StringProtocol>(_ title: S, text: Binding<String>) {
         field = TextField(placeholder: String(title), text: text, secure: true)
     }
@@ -194,6 +200,11 @@ public struct Toggle<Label: View> {
     }
 }
 extension Toggle where Label == Text {
+    public init(_ titleKey: LocalizedStringKey, isOn: Binding<Bool>) {
+        self.init(isOn: isOn) { Text(titleKey) }
+    }
+
+    @_disfavoredOverload
     public init<S: StringProtocol>(_ title: S, isOn: Binding<Bool>) {
         self.init(isOn: isOn) { Text(title) }
     }
@@ -229,6 +240,7 @@ public struct Label<Title: View, Icon: View>: View {
 }
 
 extension Label where Title == Text, Icon == Image {
+    @_disfavoredOverload
     public init<S: StringProtocol>(_ title: S, systemImage: String) {
         self.title = Text(title)
         self.icon = Image(systemName: systemImage)
@@ -239,15 +251,21 @@ extension Label where Title == Text, Icon == Image {
         self.icon = Image(systemName: systemImage)
     }
 
+    @_disfavoredOverload
     public init<S: StringProtocol>(_ title: S, image name: String) {
         self.title = Text(title)
         self.icon = Image(name)
     }
+
+    public init(_ titleKey: LocalizedStringKey, image name: String) {
+        self.title = Text(titleKey)
+        self.icon = Image(name)
+    }
 }
 
 // MARK: - Enabling
 
-extension View {
+nonisolated extension View {
     public func disabled(_ disabled: Bool) -> some View {
         _styled { $0.disabled = disabled ? true : nil }
     }
@@ -256,6 +274,20 @@ extension View {
     public func onAppear(perform action: (@MainActor () -> Void)? = nil) -> some View {
         _OnAppearView(content: self, action: action)
     }
+
+    /// Runs `action` once the view has left the screen (after the render that removed it).
+    public func onDisappear(perform action: (@MainActor () -> Void)? = nil) -> some View {
+        _OnDisappearView(content: self, action: action)
+    }
+}
+
+struct _OnDisappearView<Content: View> {
+    let content: Content
+    let action: (@MainActor () -> Void)?
+}
+extension _OnDisappearView: _PrimitiveView {}
+extension _OnDisappearView: _GroupView {
+    var _children: [any View] { [content] }
 }
 
 struct _OnAppearView<Content: View> {

package/Sources/SwiftUI/API/CustomLayout.swift

@@ -79,15 +79,41 @@ public struct LayoutProperties: Sendable {
 }
 
 /// A key for values a subview exposes to its layout via `layoutValue(key:value:)`.
-/// The shim does not propagate such values; the layout always sees the default.
 public protocol LayoutValueKey {
     associatedtype Value
     static var defaultValue: Value { get }
 }
 
-extension View {
-    /// Accepted for source compatibility: custom layouts read `K.defaultValue`.
-    public func layoutValue<K: LayoutValueKey>(key: K.Type, value: K.Value) -> some View { self }
+nonisolated extension View {
+    /// A value the custom layout around this view reads from its subview
+    /// (`subview[K.self]`). It travels up with the view's elements; the
+    /// value set closest to the view wins.
+    public func layoutValue<K: LayoutValueKey>(key: K.Type, value: K.Value) -> some View {
+        _LayoutValueView(content: self, key: ObjectIdentifier(K.self), value: value)
+    }
+}
+
+/// `.layoutValue(key:value:)`: its content, with the value marked on its elements.
+struct _LayoutValueView<Content: View> {
+    let content: Content
+    let key: ObjectIdentifier
+    let value: Any
+}
+extension _LayoutValueView: _PrimitiveView {}
+extension _LayoutValueView: _GroupView {
+    var _children: [any View] { [content] }
+}
+
+protocol _LayoutValueProviding: _TraitBearing {
+    var _layoutValue: (key: ObjectIdentifier, value: Any) { get }
+}
+extension _LayoutValueView: _LayoutValueProviding {
+    var _layoutValue: (key: ObjectIdentifier, value: Any) { (key, value) }
+}
+
+/// A custom layout's element learns its children's layout values as it is produced.
+protocol _LayoutValuesReceiving {
+    func _receive(childLayoutValues: [[ObjectIdentifier: Any]])
 }
 
 /// A proxy for one child of a custom layout.
@@ -102,6 +128,8 @@ public struct LayoutSubview {
     let ideal: CGSize
     let max: CGSize
     let placements: _LayoutPlacements
+    /// The child's `.layoutValue`s, by key type.
+    var values: [ObjectIdentifier: Any] = [:]
 
     public func sizeThatFits(_ proposal: ProposedViewSize) -> CGSize {
         CGSize(
@@ -125,7 +153,9 @@ public struct LayoutSubview {
 
     public var priority: Double { 0 }
 
-    public subscript<K: LayoutValueKey>(key: K.Type) -> K.Value { K.defaultValue }
+    public subscript<K: LayoutValueKey>(key: K.Type) -> K.Value {
+        values[ObjectIdentifier(key)] as? K.Value ?? K.defaultValue
+    }
 
     /// Records where the child goes. Its size is `sizeThatFits(proposal)` and
     /// `anchor` says which point of that size sits at `position`.
@@ -272,9 +302,11 @@ struct _LayoutSizes: Equatable {
     }
 }
 
-/// Holds a layout's cache across measurements without triggering renders.
+/// Holds a layout's cache across measurements without triggering renders,
+/// and its children's layout values as last produced.
 final class _LayoutCacheBox {
     var cache: Any?
+    var childValues: [[ObjectIdentifier: Any]] = []
 }
 
 /// The element a custom layout renders as: kind `layout`, the children
@@ -307,15 +339,22 @@ extension _LayoutView: _HostView {
         let resultBox = _result.box
         let cacheBox = self.cacheBox
         return { event in
-            guard let (proposal, subviews) = _parseLayoutEvent(event) else { return }
+            guard let (proposal, subviews) = _parseLayoutEvent(event, values: cacheBox.childValues) else { return }
             let computed = _runLayout(layout, proposal: proposal, subviews: subviews, cacheBox: cacheBox)
             if computed != resultBox.value { resultBox.value = computed }
         }
     }
 }
 
-/// Parses `{"proposal": {...}, "children": [{"min", "ideal", "max"}]}`.
-func _parseLayoutEvent(_ event: _JSON) -> (ProposedViewSize, LayoutSubviews)? {
+extension _LayoutView: _LayoutValuesReceiving {
+    func _receive(childLayoutValues: [[ObjectIdentifier: Any]]) {
+        cacheBox.childValues = childLayoutValues
+    }
+}
+
+/// Parses `{"proposal": {...}, "children": [{"min", "ideal", "max"}]}`;
+/// `values` are the children's layout values, in order.
+func _parseLayoutEvent(_ event: _JSON, values: [[ObjectIdentifier: Any]] = []) -> (ProposedViewSize, LayoutSubviews)? {
     guard case .object(let fields) = event else { return nil }
     let proposal: ProposedViewSize
     if case .object(let p)? = fields["proposal"] {
@@ -331,7 +370,7 @@ func _parseLayoutEvent(_ event: _JSON) -> (ProposedViewSize, LayoutSubviews)? {
             return CGSize(width: _dimension(s["width"]) ?? 0, height: _dimension(s["height"]) ?? 0)
         }
         return LayoutSubview(index: index, min: size("min"), ideal: size("ideal"), max: size("max"),
-                             placements: placements)
+                             placements: placements, values: index < values.count ? values[index] : [:])
     }
     return (proposal, LayoutSubviews(subviews))
 }

package/Sources/SwiftUI/API/CustomToolbarContent.swift

@@ -0,0 +1,46 @@
+// Toolbar content types of the app's own, with a `body` (Ice Cubes'
+// `CancelToolbarItem` reads `@Environment(\.dismiss)` and returns a
+// `ToolbarItem`). Such content becomes a view in the toolbar: when it is
+// rendered, its `@Environment` properties are resolved from the environment
+// where the toolbar is, its `body` runs, and the items it makes are placed
+// like any others.
+
+extension Never: ToolbarContent {
+    nonisolated public var _toolbarItems: [any View] { [] }
+}
+
+/// Content the toolbar reads directly instead of evaluating `body`.
+extension ToolbarContent where Body == Never {
+    public var body: Never { fatalError("\(Self.self) is primitive toolbar content and has no body") }
+}
+
+extension ToolbarContent {
+    /// A view that evaluates `body` in the toolbar's environment.
+    nonisolated public var _toolbarItems: [any View] { [_CustomToolbarContentView(content: self)] }
+}
+
+struct _CustomToolbarContentView<Content: ToolbarContent> {
+    let content: Content
+    @Environment(\.self) private var environment
+}
+
+extension _CustomToolbarContentView: View {
+    var body: some View {
+        // The content is not a view, so the runtime does not resolve its
+        // properties: do it here, with this view's environment.
+        for child in Mirror(reflecting: content).children {
+            (child.value as? any _EnvironmentProperty)?._resolve(in: environment)
+            (child.value as? any _EnvironmentReading)?._resolve(in: environment)
+        }
+        return _ToolbarItemsView(items: content.body._toolbarItems)
+    }
+}
+
+/// The toolbar groups a custom content made, as siblings.
+struct _ToolbarItemsView {
+    let items: [any View]
+}
+extension _ToolbarItemsView: _PrimitiveView {}
+extension _ToolbarItemsView: _GroupView {
+    var _children: [any View] { items }
+}

package/Sources/SwiftUI/API/Decorations.swift

@@ -47,7 +47,7 @@ extension _EnvironmentBackgroundShape: _HostView {
     }
 }
 
-extension View {
+nonisolated extension View {
     public func overlay<V: View>(alignment: Alignment = .center, @ViewBuilder content: () -> V) -> some View {
         _DecoratedView(content: self, decoration: content(), role: "overlay", alignment: alignment)
     }