@swiftbrowser/swift 0.1.0 → 0.3.0

package/Sources/SwiftUI/API/Toolbar.swift

@@ -23,9 +23,14 @@ public struct ToolbarItemPlacement: Hashable, Sendable {
     public static let navigationBarTrailing = ToolbarItemPlacement(name: "trailing")
 }
 
-/// Content of a `.toolbar`: items, groups, title menus or plain views.
+/// Content of a `.toolbar`: items, groups, title menus or plain views, or a
+/// type of the app's with a `body` (CustomToolbarContent.swift). Main-actor
+/// isolated, as SwiftUI's is.
+@MainActor @preconcurrency
 public protocol ToolbarContent {
-    var _toolbarItems: [any View] { get }
+    associatedtype Body: ToolbarContent
+    @ToolbarContentBuilder var body: Body { get }
+    nonisolated var _toolbarItems: [any View] { get }
 }
 
 /// A `toolbar` element: the items of one placement.
@@ -47,7 +52,7 @@ extension _ToolbarGroupView: _EnvironmentModifying {
     }
 }
 
-public struct ToolbarItem<ID, Content: View>: ToolbarContent {
+nonisolated public struct ToolbarItem<ID, Content: View>: ToolbarContent {
     let placement: ToolbarItemPlacement
     let content: Content
 
@@ -61,10 +66,10 @@ public struct ToolbarItem<ID, Content: View>: ToolbarContent {
         self.content = content()
     }
 
-    public var _toolbarItems: [any View] { [_ToolbarGroupView(placement: placement, items: [content])] }
+    nonisolated public var _toolbarItems: [any View] { [_ToolbarGroupView(placement: placement, items: [content])] }
 }
 
-public struct ToolbarItemGroup<Content: View>: ToolbarContent {
+nonisolated public struct ToolbarItemGroup<Content: View>: ToolbarContent {
     let placement: ToolbarItemPlacement
     let content: Content
 
@@ -73,22 +78,23 @@ public struct ToolbarItemGroup<Content: View>: ToolbarContent {
         self.content = content()
     }
 
-    public var _toolbarItems: [any View] { [_ToolbarGroupView(placement: placement, items: [content])] }
+    nonisolated public var _toolbarItems: [any View] { [_ToolbarGroupView(placement: placement, items: [content])] }
 }
 
 /// Accepted for source compatibility; the title has no menu in the browser.
-public struct ToolbarTitleMenu<Content: View>: ToolbarContent {
+nonisolated public struct ToolbarTitleMenu<Content: View>: ToolbarContent {
     public init(@ViewBuilder content: () -> Content) { _ = content() }
-    public var _toolbarItems: [any View] { [] }
+    nonisolated public var _toolbarItems: [any View] { [] }
 }
 
-struct _ToolbarContentList: ToolbarContent {
+/// Several contents in order (a builder's block, `if`/`else` branches).
+nonisolated public struct _ToolbarContentList: ToolbarContent {
     let parts: [any ToolbarContent]
-    var _toolbarItems: [any View] { parts.flatMap(\._toolbarItems) }
+    nonisolated public var _toolbarItems: [any View] { parts.flatMap(\._toolbarItems) }
 }
 
-struct _EmptyToolbarContent: ToolbarContent {
-    var _toolbarItems: [any View] { [] }
+nonisolated struct _EmptyToolbarContent: ToolbarContent {
+    nonisolated var _toolbarItems: [any View] { [] }
 }
 
 @resultBuilder
@@ -109,14 +115,20 @@ public enum ToolbarContentBuilder {
         _ToolbarContentList(parts: content.map { [$0] } ?? [])
     }
 
-    public static func buildEither<T: ToolbarContent>(first: T) -> some ToolbarContent {
+    // Both branches of an `if`/`else` must build the same type.
+    public static func buildEither<T: ToolbarContent>(first: T) -> _ToolbarContentList {
         _ToolbarContentList(parts: [first])
     }
 
-    public static func buildEither<F: ToolbarContent>(second: F) -> some ToolbarContent {
+    public static func buildEither<F: ToolbarContent>(second: F) -> _ToolbarContentList {
         _ToolbarContentList(parts: [second])
     }
 
+    /// `if #available(…)`.
+    public static func buildLimitedAvailability<C: ToolbarContent>(_ content: C) -> _ToolbarContentList {
+        _ToolbarContentList(parts: [content])
+    }
+
     public static func buildIf<C: ToolbarContent>(_ content: C?) -> some ToolbarContent {
         _ToolbarContentList(parts: content.map { [$0] } ?? [])
     }
@@ -133,7 +145,7 @@ extension _ToolbarView: _GroupView {
     var _children: [any View] { [content] + groups }
 }
 
-extension View {
+nonisolated extension View {
     public func toolbar<C: ToolbarContent>(@ToolbarContentBuilder content: () -> C) -> some View {
         _ToolbarView(content: self, groups: content()._toolbarItems)
     }
@@ -197,12 +209,13 @@ public struct SearchFieldPlacement: Hashable, Sendable {
     public static let navigationBarDrawer = SearchFieldPlacement(name: "navigationBarDrawer")
 }
 
-extension View {
+nonisolated extension View {
     public func searchable(text: Binding<String>, placement: SearchFieldPlacement = .automatic,
                            prompt: Text? = nil) -> some View {
         _SearchableView(content: self, field: _SearchFieldView(text: text, prompt: prompt?.content ?? "Search"))
     }
 
+    @_disfavoredOverload
     public func searchable<S: StringProtocol>(text: Binding<String>, placement: SearchFieldPlacement = .automatic,
                                               prompt: S) -> some View {
         _SearchableView(content: self, field: _SearchFieldView(text: text, prompt: String(prompt)))
@@ -212,4 +225,27 @@ extension View {
                            prompt: LocalizedStringKey) -> some View {
         _SearchableView(content: self, field: _SearchFieldView(text: text, prompt: prompt.key))
     }
+
+    /// Suggestions under the search field. The page's search field shows
+    /// none: the views are not drawn, and searching works as typed.
+    public func searchSuggestions<S: View>(@ViewBuilder _ suggestions: () -> S) -> some View { self }
+
+    public func searchSuggestions(_ visibility: Visibility, for placements: SearchSuggestionsPlacement.Set) -> some View { self }
+
+    /// The text a suggestion completes the search with (see `searchSuggestions`).
+    public func searchCompletion(_ completion: String) -> some View { self }
+}
+
+/// Where search suggestions show; accepted (see `searchSuggestions`).
+public struct SearchSuggestionsPlacement: Equatable, Sendable {
+    public static let automatic = SearchSuggestionsPlacement()
+    public static let menu = SearchSuggestionsPlacement()
+    public static let content = SearchSuggestionsPlacement()
+
+    public struct Set: OptionSet, Sendable {
+        public let rawValue: Int
+        public init(rawValue: Int) { self.rawValue = rawValue }
+        public static let menu = Set(rawValue: 1)
+        public static let content = Set(rawValue: 2)
+    }
 }

package/Sources/SwiftUI/API/Transfer.swift

@@ -0,0 +1,145 @@
+import Foundation
+// As on iOS, SwiftUI brings CoreTransferable (`Transferable` and its
+// representations) and with it UniformTypeIdentifiers' `UTType`.
+@_exported import CoreTransferable
+
+// SwiftUI's side of `Transferable`: `Image` as a transferable value,
+// `ShareLink`'s export of other items, and the drag-and-drop and clipboard
+// modifiers that take `Transferable` payloads (docs/ops-protocol.md,
+// "Sharing and media").
+
+// MARK: - Image
+
+extension Image: Transferable {
+    /// Exports the bytes of an image made from a file (`Image(uiImage:
+    /// UIImage(data:))`), in that file's type; a symbol, a catalog image, a
+    /// remote image or a Core Image result has no bytes in Swift and exports
+    /// nothing. Imports any image file the page can draw.
+    public static var transferRepresentation: _TransferRepresentationList<Image> {
+        return _TransferRepresentationList(nodes: [
+            _TransferNode(
+                exportType: .image, importType: .image,
+                exporter: { item, wanted in
+                    guard let image = item as? Image, case .bitmap(let recipe, _, _) = image.source, recipe.steps.isEmpty,
+                          let file = recipe.source?.encodedFile, let type = UTType(mimeType: file.mime, conformingTo: .image)
+                    else { return nil }
+                    if let wanted, !type.conforms(to: wanted) { return nil }
+                    return _TransferContent(contentType: type, data: file.data)
+                },
+                importer: { content in
+                    guard let uiImage = UIImage(data: try content.loadData()) else { return nil }
+                    return Image(uiImage: uiImage)
+                }),
+        ])
+    }
+}
+
+extension _ImageSource {
+    /// The encoded file this source is (its bytes and MIME type); nil for a pixel buffer.
+    public var encodedFile: (data: Data, mime: String)? {
+        if case .encoded(let bytes, let mime) = payload { return (Data(bytes), mime) }
+        return nil
+    }
+}
+
+extension UIImage {
+    /// The file an image made with `UIImage(data:)` came from, unchanged
+    /// (its bytes and MIME type); nil for any other image. The pasteboard,
+    /// the photo library and item providers hand these bytes on as they are.
+    public var _encodedFile: (data: Data, mime: String)? {
+        guard case .bitmap(let recipe) = content, recipe.steps.isEmpty else { return nil }
+        return recipe.source?.encodedFile
+    }
+}
+
+extension _ImageRecipe {
+    /// The recipe as a `share` or `download` request carries it (`bitmaps`).
+    public var _json: _JSON { json }
+}
+
+extension UIImage {
+    /// The asset-catalog name of `UIImage(named:)`; nil for any other image.
+    public var _catalogName: String? {
+        if case .named(let name) = content { return name }
+        return nil
+    }
+}
+
+// MARK: - Sharing other items
+
+/// A value the compiler cannot prove `Sendable` that stays on the browser's one thread.
+struct _UncheckedSendableBox<Value>: @unchecked Sendable {
+    let value: Value
+    init(_ value: Value) { self.value = value }
+}
+
+/// `ShareLink` items other than `String`, `URL` and `Image`: each is
+/// exported through its first exporting representation. A `String` or `URL`
+/// proxy joins the text and link; bytes or a file join the `files` the page
+/// shares (`{name, type, data}`, data in base64). An item that exports
+/// nothing, or fails, is left out.
+@MainActor
+enum _ShareExport {
+    static func payload(_ base: _JSON, adding items: [any Transferable], title: String?) async -> _JSON {
+        guard case .object(var fields) = base else { return base }
+        var texts: [String] = []
+        if case .string(let text)? = fields["text"] { texts.append(text) }
+        var files: [_JSON] = []
+        for item in items {
+            guard let content = try? await _Transfer.export(item) else { continue }
+            switch content.value {
+            case let text as String:
+                texts.append(text)
+                continue
+            case let url as URL:
+                if fields["url"] == nil { fields["url"] = .string(url.absoluteString) } else { texts.append(url.absoluteString) }
+                continue
+            default:
+                break
+            }
+            guard let data = try? content.loadData() else { continue }
+            var named = content
+            if named.suggestedName == nil, named.file == nil { named.suggestedName = title }
+            files.append(.object([
+                "name": .string(named.fileName),
+                "type": .string(content.contentType.preferredMIMEType ?? "application/octet-stream"),
+                "data": .string(_base64([UInt8](data))),
+            ]))
+        }
+        if !texts.isEmpty { fields["text"] = .string(texts.joined(separator: "\n")) }
+        if !files.isEmpty { fields["files"] = .array(files) }
+        return .object(fields)
+    }
+}
+
+// MARK: - Drag and drop, copy and paste
+
+// The page has no drag and drop between views or apps yet, and the clipboard
+// takes text through `UIPasteboard` (UIKit). These modifiers accept their
+// payloads and actions and leave the view as it is: nothing is dragged,
+// nothing is dropped, and the actions are never called.
+
+extension View {
+    /// Accepted; the view cannot be dragged in the browser.
+    public func draggable<T: Transferable>(_ payload: @autoclosure @escaping () -> T) -> some View { self }
+
+    /// Accepted; the view cannot be dragged in the browser.
+    public func draggable<T: Transferable, Preview: View>(_ payload: @autoclosure @escaping () -> T,
+                                                          @ViewBuilder preview: () -> Preview) -> some View { self }
+
+    /// Accepted; nothing is dropped in the browser, so `action` is never called
+    /// and `isTargeted` never reports true.
+    public func dropDestination<T: Transferable>(for payloadType: T.Type = T.self,
+                                                 action: @escaping ([T], CGPoint) -> Bool,
+                                                 isTargeted: @escaping (Bool) -> Void = { _ in }) -> some View { self }
+
+    /// Accepted; the browser's copy command copies the page's selected text.
+    public func copyable<T: Transferable>(_ payload: @autoclosure @escaping () -> [T]) -> some View { self }
+
+    /// Accepted; the browser's cut command acts on the page's selected text.
+    public func cuttable<T: Transferable>(for payloadType: T.Type = T.self, action: @escaping () -> [T]) -> some View { self }
+
+    /// Accepted; the browser's paste command pastes text into a focused field.
+    public func pasteDestination<T: Transferable>(for payloadType: T.Type = T.self, action: @escaping ([T]) -> Void,
+                                                  validator: @escaping ([T]) -> [T] = { $0 }) -> some View { self }
+}

package/Sources/SwiftUI/API/UnevenRoundedRectangle.swift

@@ -0,0 +1,66 @@
+/// A rectangle with a radius of its own at each corner (iOS 16). The page's
+/// shapes, clips and shape backgrounds have one corner radius, so it is drawn
+/// with its largest radius at every corner (an approximation; a sheet-like
+/// panel rounded on top only is rounded at the bottom too).
+nonisolated public struct UnevenRoundedRectangle: Shape {
+    public var cornerRadii: RectangleCornerRadii
+    public var style: RoundedCornerStyle
+
+    public init(cornerRadii: RectangleCornerRadii, style: RoundedCornerStyle = .continuous) {
+        self.cornerRadii = cornerRadii
+        self.style = style
+    }
+
+    public init(topLeadingRadius: CGFloat = 0, bottomLeadingRadius: CGFloat = 0, bottomTrailingRadius: CGFloat = 0,
+                topTrailingRadius: CGFloat = 0, style: RoundedCornerStyle = .continuous) {
+        self.init(cornerRadii: RectangleCornerRadii(topLeading: topLeadingRadius, bottomLeading: bottomLeadingRadius,
+                                                    bottomTrailing: bottomTrailingRadius, topTrailing: topTrailingRadius),
+                  style: style)
+    }
+
+    public func path(in rect: CGRect) -> Path { Path(roundedRect: rect, cornerRadii: cornerRadii, style: style) }
+
+    public var _name: String { "roundedRectangle" }
+    public var _cornerRadius: CGFloat {
+        max(cornerRadii.topLeading, cornerRadii.bottomLeading, cornerRadii.bottomTrailing, cornerRadii.topTrailing)
+    }
+}
+
+/// The four corner radii of an `UnevenRoundedRectangle`.
+public struct RectangleCornerRadii: Equatable, Sendable {
+    public var topLeading: CGFloat
+    public var bottomLeading: CGFloat
+    public var bottomTrailing: CGFloat
+    public var topTrailing: CGFloat
+
+    public init(topLeading: CGFloat = 0, bottomLeading: CGFloat = 0, bottomTrailing: CGFloat = 0, topTrailing: CGFloat = 0) {
+        self.topLeading = topLeading
+        self.bottomLeading = bottomLeading
+        self.bottomTrailing = bottomTrailing
+        self.topTrailing = topTrailing
+    }
+}
+
+extension Shape where Self == UnevenRoundedRectangle {
+    public static func rect(topLeadingRadius: CGFloat = 0, bottomLeadingRadius: CGFloat = 0, bottomTrailingRadius: CGFloat = 0,
+                            topTrailingRadius: CGFloat = 0, style: RoundedCornerStyle = .continuous) -> UnevenRoundedRectangle {
+        UnevenRoundedRectangle(topLeadingRadius: topLeadingRadius, bottomLeadingRadius: bottomLeadingRadius,
+                               bottomTrailingRadius: bottomTrailingRadius, topTrailingRadius: topTrailingRadius, style: style)
+    }
+
+    public static func rect(cornerRadii: RectangleCornerRadii, style: RoundedCornerStyle = .continuous) -> UnevenRoundedRectangle {
+        UnevenRoundedRectangle(cornerRadii: cornerRadii, style: style)
+    }
+}
+
+extension UnevenRoundedRectangle: View {
+    public typealias Body = Never
+    public var body: Never { fatalError("UnevenRoundedRectangle is a primitive view") }
+}
+extension UnevenRoundedRectangle: _PrimitiveView {}
+extension UnevenRoundedRectangle: _HostView {
+    var _kind: String { "shape" }
+    func _props(in environment: EnvironmentValues) -> _JSON {
+        _ShapeView(shape: self, fill: nil, stroke: nil)._props(in: environment)
+    }
+}

package/Sources/SwiftUI/API/Video.swift

@@ -0,0 +1,64 @@
+/// The `video` element (docs/ops-protocol.md, "Video and audio"): an HTML
+/// `<video>` the page plays. The shim's SwiftUI has no video view of its own;
+/// AVFoundation builds one on this (`AVPlayer`'s views: AVKit's
+/// `VideoPlayer`, an `AVPlayerLayer` in a UIKit view), with the props worked
+/// out from the player and a handler for the page's `video` events.
+///
+/// Public so the frameworks above SwiftUI can emit the element; apps never
+/// name it.
+public struct _VideoElement {
+    let props: _JSON
+    let handler: (_JSON) -> Void
+
+    /// `props` are the element's (see the protocol document); `handler`
+    /// receives each `video` event whole (`{"type": "video", "id", "event", …}`).
+    public init(props: _JSON, handler: @escaping (_JSON) -> Void) {
+        self.props = props
+        self.handler = handler
+    }
+}
+extension _VideoElement: _PrimitiveView {}
+extension _VideoElement: _HostView {
+    var _kind: String { "video" }
+    func _props(in environment: EnvironmentValues) -> _JSON { props }
+    var _handler: ((_JSON) -> Void)? { handler }
+}
+
+extension _Runtime {
+    /// The `response` fields for a headless `media` request (AVFoundation's
+    /// files and probes, QuickLook's previews): a `file` gets a stand-in URL,
+    /// a `probe` the `duration` / `width` / `height` of the `SB_RESPONSES`
+    /// entry whose `url` (exact) or `prefix` matches and that has a
+    /// `duration`, an `open` finds no tab to open (`opened: false`).
+    nonisolated static func _headlessMedia(params: _JSON, fixtures: [_JSON], serial: Int) -> [String: _JSON] {
+        guard case .object(let request) = params, case .string(let action)? = request["action"] else {
+            return ["error": .string("malformed request")]
+        }
+        switch action {
+        case "file":
+            return ["value": .object(["url": .string("blob:headless/\(serial)")])]
+        case "release":
+            return ["value": .object([:])]
+        case "open":
+            return ["value": .object(["opened": .bool(false)])]
+        case "probe":
+            guard case .string(let url)? = request["url"] else { return ["error": .string("malformed request")] }
+            let fixture = fixtures.first { item in
+                guard case .object(let fields) = item, fields["duration"] != nil else { return false }
+                if case .string(let exact)? = fields["url"], exact == url { return true }
+                if case .string(let prefix)? = fields["prefix"], url.hasPrefix(prefix) { return true }
+                return false
+            }
+            guard case .object(let fields)? = fixture else {
+                return ["error": .string("headless: no SB_RESPONSES entry with a duration for \(url)")]
+            }
+            return ["value": .object([
+                "duration": fields["duration"] ?? .null,
+                "width": fields["width"] ?? .number(0),
+                "height": fields["height"] ?? .number(0),
+            ])]
+        default:
+            return ["error": .string("headless: unknown media action \(action)")]
+        }
+    }
+}

package/Sources/SwiftUI/API/View.swift

@@ -25,18 +25,53 @@ extension _PrimitiveView {
 
 /// A view whose only job is to contribute other views to its parent.
 /// Tuples, optionals, conditionals, `Group`, `AnyView` and `ForEach` are groups.
-protocol _GroupView {
+protocol _GroupView: _TraitBearing {
     var _children: [any View] { get }
     /// Stable identities for `_children`, when the group is keyed (`ForEach`).
     var _keys: [AnyHashable]? { get }
+    /// Whether the group is more than a wrapper of one view: it has other
+    /// than one child, or keys. A modifier applied to such a group applies
+    /// to each of its children (`_StyledGroup`).
+    var _spreads: Bool { get }
 }
 
 extension _GroupView {
     var _keys: [AnyHashable]? { nil }
+    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).
-protocol _HostView {
+protocol _HostView: _TraitBearing {
     var _kind: String { get }
     func _props(in environment: EnvironmentValues) -> _JSON
     var _content: [any View] { get }
@@ -92,6 +127,7 @@ public struct EmptyView: Sendable {
     public init() {}
 }
 extension EmptyView: _PrimitiveView {}
+extension EmptyView: _TransparentGroup {}
 extension EmptyView: _GroupView {
     var _children: [any View] { [] }
 }
@@ -106,6 +142,7 @@ public struct TupleView<T> {
     }
 }
 extension TupleView: _PrimitiveView {}
+extension TupleView: _TransparentGroup {}
 extension TupleView: _GroupView {
     var _children: [any View] { children }
 }
@@ -118,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 {
@@ -131,6 +169,9 @@ extension Optional: View where Wrapped: View {
     public typealias Body = Never
     public var body: Never { fatalError("Optional is a primitive view and has no body") }
 }
+// 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 {
@@ -148,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] }
 }
@@ -158,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] }
 }
@@ -201,6 +244,7 @@ extension ForEach: View where Content: View {
     public typealias Body = Never
 }
 extension ForEach: _PrimitiveView where Content: View {}
+extension ForEach: _TraitBearing {}
 extension ForEach: _GroupView where Content: View {
     var _children: [any View] { data.map { content($0) } }
     var _keys: [AnyHashable]? { data.map { AnyHashable(id($0)) } }

package/Sources/SwiftUI/API/ViewModifier.swift

@@ -33,8 +33,11 @@ public struct ModifiedContent<Content: View, Modifier: ViewModifier>: View {
     }
 }
 
-extension View {
+nonisolated extension View {
+    @MainActor
     public func modifier<M: ViewModifier>(_ modifier: M) -> ModifiedContent<Self, M> {
         ModifiedContent(content: self, modifier: modifier)
     }
 }
+
+extension ModifiedContent: _HoldsModifier {}

package/Sources/SwiftUI/API/VisualEffect.swift

@@ -71,7 +71,7 @@ extension VisualEffect {
     public func colorEffect<S: ShapeStyle>(_ shader: S) -> _VisualEffectChain { _adding { _ in } }
 }
 
-extension View {
+nonisolated extension View {
     public func visualEffect(_ effect: @escaping (EmptyVisualEffect, GeometryProxy) -> some VisualEffect) -> some View {
         let result = effect(EmptyVisualEffect(), GeometryProxy(size: .zero))
         let effects = (result as? _VisualEffectChaining)?._effects ?? []
@@ -80,3 +80,76 @@ extension View {
         }
     }
 }
+
+// MARK: - Scroll transitions
+
+/// Where a view is in its scroll view, for `.scrollTransition`: about to
+/// enter at the top leading edge, fully visible (`identity`), or leaving at
+/// the bottom trailing edge.
+public enum ScrollTransitionPhase: Hashable, Sendable {
+    case topLeading, identity, bottomTrailing
+
+    public var isIdentity: Bool { self == .identity }
+
+    /// -1 at the top leading edge, 0 when visible, 1 at the bottom trailing edge.
+    public var value: Double {
+        switch self {
+        case .topLeading: -1
+        case .identity: 0
+        case .bottomTrailing: 1
+        }
+    }
+}
+
+/// When a scroll transition applies its effect; accepted.
+public struct ScrollTransitionConfiguration: Sendable {
+    public static let identity = ScrollTransitionConfiguration()
+    public static func animated(_ animation: Animation = .default) -> ScrollTransitionConfiguration { .init() }
+    public static let animated = ScrollTransitionConfiguration()
+    public static func interactive(timingCurve: UnitCurve = .easeInOut) -> ScrollTransitionConfiguration { .init() }
+    public static let interactive = ScrollTransitionConfiguration()
+    public func threshold(_ threshold: ScrollTransitionConfiguration.Threshold) -> ScrollTransitionConfiguration { self }
+    public func animation(_ animation: Animation) -> ScrollTransitionConfiguration { self }
+
+    public struct Threshold: Sendable {
+        public static let visible = Threshold()
+        public static let hidden = Threshold()
+        public static var centered: Threshold { Threshold() }
+        public static func visible(_ amount: Double) -> Threshold { Threshold() }
+        public func interpolated(towards other: Threshold, amount: Double) -> Threshold { self }
+        public func inset(by distance: Double) -> Threshold { self }
+    }
+}
+
+nonisolated extension View {
+    /// The effect for a view as it scrolls in and out. The browser does not
+    /// report where a view is on every scroll step, so the view shows the
+    /// effect of the `identity` phase: as it is when fully visible.
+    public func scrollTransition(_ configuration: ScrollTransitionConfiguration = .interactive, axis: Axis? = nil,
+                                 transition: @escaping (EmptyVisualEffect, ScrollTransitionPhase) -> some VisualEffect) -> some View {
+        let result = transition(EmptyVisualEffect(), .identity)
+        let effects = (result as? _VisualEffectChaining)?._effects ?? []
+        return _styled { style in
+            for apply in effects { apply(&style) }
+        }
+    }
+
+    public func scrollTransition(topLeading: ScrollTransitionConfiguration, bottomTrailing: ScrollTransitionConfiguration, axis: Axis? = nil,
+                                 transition: @escaping (EmptyVisualEffect, ScrollTransitionPhase) -> some VisualEffect) -> some View {
+        scrollTransition(topLeading, axis: axis, transition: transition)
+    }
+}
+
+/// A timing curve over 0…1 (iOS 17), as scroll transitions take; the
+/// browser's transitions do not use it.
+public struct UnitCurve: Hashable, Sendable {
+    let name: String
+    public static let linear = UnitCurve(name: "linear")
+    public static let easeIn = UnitCurve(name: "easeIn")
+    public static let easeOut = UnitCurve(name: "easeOut")
+    public static let easeInOut = UnitCurve(name: "easeInOut")
+    public static let circularEaseIn = UnitCurve(name: "circularEaseIn")
+    public static let circularEaseOut = UnitCurve(name: "circularEaseOut")
+    public static let circularEaseInOut = UnitCurve(name: "circularEaseInOut")
+    public static func bezier(startControlPoint: UnitPoint, endControlPoint: UnitPoint) -> UnitCurve { UnitCurve(name: "bezier") }
+}

package/Sources/SwiftUI/API/Windows.swift

@@ -0,0 +1,25 @@
+// Scene windows: `@Environment(\.openWindow)`, `\.dismissWindow` and
+// `\.supportsMultipleWindows`. The page is the app's one window, so it
+// reports no support for more, opening a window does nothing, and dismissing
+// one does nothing either.
+
+/// Opens a window of a `WindowGroup`. Does nothing: the page is one window.
+public struct OpenWindowAction: Sendable {
+    @MainActor public func callAsFunction(id: String) {}
+    @MainActor public func callAsFunction<D: Decodable & Encodable & Hashable>(value: D) {}
+    @MainActor public func callAsFunction<D: Decodable & Encodable & Hashable>(id: String, value: D) {}
+}
+
+/// Dismisses a window. Does nothing: the page is one window.
+public struct DismissWindowAction: Sendable {
+    @MainActor public func callAsFunction() {}
+    @MainActor public func callAsFunction(id: String) {}
+    @MainActor public func callAsFunction<D: Decodable & Encodable & Hashable>(value: D) {}
+}
+
+extension EnvironmentValues {
+    public var openWindow: OpenWindowAction { OpenWindowAction() }
+    public var dismissWindow: DismissWindowAction { DismissWindowAction() }
+    /// False: the page is one window.
+    public var supportsMultipleWindows: Bool { false }
+}