@swiftbrowser/swift 0.0.0-stage → 0.1.0

package/Sources/SwiftUI/API/Timeline.swift

@@ -0,0 +1,212 @@
+// TimelineView: content re-rendered on a schedule. The shim has no Foundation
+// `Date`, so the context carries `_TimelineDate` (seconds since 1970); Apple
+// code reading `context.date.timeIntervalSince1970` compiles unchanged. Ticks
+// run on the host-driven executor like `.task` does and stop when the view
+// leaves the tree. See docs/ops-protocol.md (Phase 6).
+
+#if canImport(WASILibc)
+import WASILibc
+#elseif canImport(Glibc)
+import Glibc
+#elseif canImport(Musl)
+import Musl
+#elseif canImport(Darwin)
+import Darwin
+#endif
+
+// MARK: - Dates
+
+/// A point in time, as seconds since 1970. Stands in for Foundation's `Date`.
+public struct _TimelineDate: Hashable, Comparable, Sendable {
+    public var timeIntervalSince1970: Double
+
+    public init(timeIntervalSince1970: Double) {
+        self.timeIntervalSince1970 = timeIntervalSince1970
+    }
+
+    /// The current time (the wall clock; fixed in headless snapshots).
+    public static var now: _TimelineDate { _TimelineDate(timeIntervalSince1970: _timelineNow()) }
+
+    public func timeIntervalSince(_ other: _TimelineDate) -> Double {
+        timeIntervalSince1970 - other.timeIntervalSince1970
+    }
+
+    public func addingTimeInterval(_ interval: Double) -> _TimelineDate {
+        _TimelineDate(timeIntervalSince1970: timeIntervalSince1970 + interval)
+    }
+
+    public static func < (lhs: _TimelineDate, rhs: _TimelineDate) -> Bool {
+        lhs.timeIntervalSince1970 < rhs.timeIntervalSince1970
+    }
+}
+
+/// Seconds since 1970 from the platform clock.
+func _wallClockSeconds() -> Double {
+    var tv = timeval()
+    gettimeofday(&tv, nil)
+    return Double(tv.tv_sec) + Double(tv.tv_usec) / 1_000_000
+}
+
+/// How `TimelineView` reads the time and waits between ticks. Headless
+/// snapshot runs (`SB_HEADLESS`) derive the time from the executor's virtual
+/// clock so output is byte-stable; tests swap both for a virtual clock.
+/// Wasm is single-threaded and tests set these from the main actor.
+enum _TimelineClock {
+    nonisolated(unsafe) static let headless = _environment("SB_HEADLESS") == "1"
+
+    nonisolated(unsafe) static var now: () -> Double = {
+        headless ? 1_700_000_000 + Double(_HostExecutor.shared.nowNs) / 1e9 : _wallClockSeconds()
+    }
+
+    nonisolated(unsafe) static var sleep: (Double) async -> Void = { seconds in
+        try? await Task.sleep(for: .seconds(seconds))
+    }
+}
+
+func _timelineNow() -> Double { _TimelineClock.now() }
+
+// MARK: - Schedules
+
+/// The mode a schedule produces entries for. Accepted for source compatibility.
+public enum TimelineScheduleMode: Hashable, Sendable {
+    case normal, lowFrequency
+}
+
+/// A schedule of times at which a `TimelineView` updates. The shim's schedules
+/// are periodic: an interval in seconds and a paused flag. A custom
+/// conformance that does not adopt the shim's `_TimelineScheduling` ticks once
+/// per second.
+public protocol TimelineSchedule {}
+
+/// What the runtime reads from a schedule.
+protocol _TimelineScheduling {
+    /// Seconds between ticks.
+    var _interval: Double { get }
+    var _paused: Bool { get }
+}
+
+/// Updates as often as animation needs. The default minimum interval is 1/20 s:
+/// every tick is a round trip through the browser renderer, so 60 fps costs
+/// too much; pass `minimumInterval` to go faster or slower.
+public struct AnimationTimelineSchedule: TimelineSchedule, _TimelineScheduling, Sendable {
+    public var minimumInterval: Double?
+    public var paused: Bool
+
+    public init(minimumInterval: Double? = nil, paused: Bool = false) {
+        self.minimumInterval = minimumInterval
+        self.paused = paused
+    }
+
+    var _interval: Double { max(minimumInterval ?? 0.05, 1.0 / 60) }
+    var _paused: Bool { paused }
+}
+
+/// Updates every `interval` seconds, starting at `startDate`.
+public struct PeriodicTimelineSchedule: TimelineSchedule, _TimelineScheduling, Sendable {
+    public var startDate: _TimelineDate
+    public var interval: Double
+
+    public init(from startDate: _TimelineDate, by interval: Double) {
+        self.startDate = startDate
+        self.interval = interval
+    }
+
+    var _interval: Double { max(interval, 1.0 / 60) }
+    var _paused: Bool { false }
+}
+
+/// Updates at the start of every minute (every 60 seconds here).
+public struct EveryMinuteTimelineSchedule: TimelineSchedule, _TimelineScheduling, Sendable {
+    public init() {}
+    var _interval: Double { 60 }
+    var _paused: Bool { false }
+}
+
+extension TimelineSchedule where Self == AnimationTimelineSchedule {
+    public static var animation: AnimationTimelineSchedule { AnimationTimelineSchedule() }
+    public static func animation(minimumInterval: Double? = nil, paused: Bool = false) -> AnimationTimelineSchedule {
+        AnimationTimelineSchedule(minimumInterval: minimumInterval, paused: paused)
+    }
+}
+
+extension TimelineSchedule where Self == PeriodicTimelineSchedule {
+    public static func periodic(from startDate: _TimelineDate, by interval: Double) -> PeriodicTimelineSchedule {
+        PeriodicTimelineSchedule(from: startDate, by: interval)
+    }
+}
+
+extension TimelineSchedule where Self == EveryMinuteTimelineSchedule {
+    public static var everyMinute: EveryMinuteTimelineSchedule { EveryMinuteTimelineSchedule() }
+}
+
+// MARK: - TimelineView
+
+/// What a `TimelineView` passes to its content on every tick.
+public struct TimelineViewDefaultContext {
+    /// The rate the view updates at.
+    public enum Cadence: Hashable, Sendable, Comparable {
+        case live, seconds, minutes
+    }
+
+    public var date: _TimelineDate
+    public var cadence: Cadence
+}
+
+/// Identity of a tick loop: when the schedule changes, the loop restarts.
+struct _TimelineTaskID: Hashable {
+    var interval: Double
+    var paused: Bool
+}
+
+/// A view whose content updates on a schedule. Renders as a plain group with
+/// a single child, `content(context)`.
+public struct TimelineView<Schedule: TimelineSchedule, Content: View> {
+    public typealias Context = TimelineViewDefaultContext
+
+    let schedule: Schedule
+    let content: (Context) -> Content
+    /// The time of the last tick; `nil` before the first.
+    @State var tick: Double? = nil
+
+    public init(_ schedule: Schedule, @ViewBuilder content: @escaping (Context) -> Content) {
+        self.schedule = schedule
+        self.content = content
+    }
+
+    var interval: Double { (schedule as? any _TimelineScheduling)?._interval ?? 1 }
+    var paused: Bool { (schedule as? any _TimelineScheduling)?._paused ?? false }
+
+    var cadence: Context.Cadence {
+        interval >= 60 ? .minutes : interval >= 1 ? .seconds : .live
+    }
+}
+extension TimelineView: _PrimitiveView {}
+extension TimelineView: _GroupView {
+    var _children: [any View] {
+        let date = _TimelineDate(timeIntervalSince1970: tick ?? _timelineNow())
+        return [content(Context(date: date, cadence: cadence))]
+    }
+}
+extension TimelineView: _TaskStarting {
+    var _taskID: AnyHashable? { AnyHashable(_TimelineTaskID(interval: interval, paused: paused)) }
+
+    var _taskAction: @Sendable () async -> Void {
+        guard !paused else { return {} }
+        let interval = self.interval
+        // The box is only touched on the main actor; the closure is built
+        // outside it, so the capture is marked as such.
+        let box = _TickBox(_tick.box)
+        return { @MainActor in
+            while !Task.isCancelled {
+                await _TimelineClock.sleep(interval)
+                if Task.isCancelled { return }
+                box.box.value = _timelineNow()
+            }
+        }
+    }
+}
+
+private struct _TickBox: @unchecked Sendable {
+    let box: _StateBox<Double?>
+    init(_ box: _StateBox<Double?>) { self.box = box }
+}

package/Sources/SwiftUI/API/Toolbar.swift

@@ -0,0 +1,215 @@
+/// `.toolbar` and `.searchable`. Items become `toolbar` / `searchfield`
+/// elements inside the screen's content; when the runtime emits a `navscreen`
+/// it hoists them to be the screen's direct children (after the content), which
+/// is where the renderer draws the navigation bar from.
+
+public struct ToolbarItemPlacement: Hashable, Sendable {
+    let name: String
+
+    public static let automatic = ToolbarItemPlacement(name: "trailing")
+    public static let primaryAction = ToolbarItemPlacement(name: "trailing")
+    public static let secondaryAction = ToolbarItemPlacement(name: "trailing")
+    public static let confirmationAction = ToolbarItemPlacement(name: "trailing")
+    public static let destructiveAction = ToolbarItemPlacement(name: "trailing")
+    public static let cancellationAction = ToolbarItemPlacement(name: "leading")
+    public static let navigation = ToolbarItemPlacement(name: "leading")
+    public static let principal = ToolbarItemPlacement(name: "principal")
+    public static let status = ToolbarItemPlacement(name: "bottom")
+    public static let bottomBar = ToolbarItemPlacement(name: "bottom")
+    public static let keyboard = ToolbarItemPlacement(name: "bottom")
+    public static let topBarLeading = ToolbarItemPlacement(name: "leading")
+    public static let topBarTrailing = ToolbarItemPlacement(name: "trailing")
+    public static let navigationBarLeading = ToolbarItemPlacement(name: "leading")
+    public static let navigationBarTrailing = ToolbarItemPlacement(name: "trailing")
+}
+
+/// Content of a `.toolbar`: items, groups, title menus or plain views.
+public protocol ToolbarContent {
+    var _toolbarItems: [any View] { get }
+}
+
+/// A `toolbar` element: the items of one placement.
+struct _ToolbarGroupView {
+    let placement: ToolbarItemPlacement
+    let items: [any View]
+}
+extension _ToolbarGroupView: _PrimitiveView {}
+extension _ToolbarGroupView: _HostView {
+    var _kind: String { "toolbar" }
+    func _props(in environment: EnvironmentValues) -> _JSON { .object(["placement": .string(placement.name)]) }
+    var _content: [any View] { items }
+}
+extension _ToolbarGroupView: _EnvironmentModifying {
+    /// Labels in a bar show their icon only, as on iOS (the title is the
+    /// accessibility label); an explicit `.labelStyle` inside an item still wins.
+    func _apply(to environment: inout EnvironmentValues) {
+        environment._labelStyle = _AnyLabelStyle.iconOnly
+    }
+}
+
+public struct ToolbarItem<ID, Content: View>: ToolbarContent {
+    let placement: ToolbarItemPlacement
+    let content: Content
+
+    public init(placement: ToolbarItemPlacement = .automatic, @ViewBuilder content: () -> Content) where ID == Void {
+        self.placement = placement
+        self.content = content()
+    }
+
+    public init(id: ID, placement: ToolbarItemPlacement = .automatic, @ViewBuilder content: () -> Content) where ID: Hashable {
+        self.placement = placement
+        self.content = content()
+    }
+
+    public var _toolbarItems: [any View] { [_ToolbarGroupView(placement: placement, items: [content])] }
+}
+
+public struct ToolbarItemGroup<Content: View>: ToolbarContent {
+    let placement: ToolbarItemPlacement
+    let content: Content
+
+    public init(placement: ToolbarItemPlacement = .automatic, @ViewBuilder content: () -> Content) {
+        self.placement = placement
+        self.content = content()
+    }
+
+    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 {
+    public init(@ViewBuilder content: () -> Content) { _ = content() }
+    public var _toolbarItems: [any View] { [] }
+}
+
+struct _ToolbarContentList: ToolbarContent {
+    let parts: [any ToolbarContent]
+    var _toolbarItems: [any View] { parts.flatMap(\._toolbarItems) }
+}
+
+struct _EmptyToolbarContent: ToolbarContent {
+    var _toolbarItems: [any View] { [] }
+}
+
+@resultBuilder
+public enum ToolbarContentBuilder {
+    public static func buildBlock() -> some ToolbarContent { _EmptyToolbarContent() }
+
+    public static func buildBlock<C: ToolbarContent>(_ content: C) -> C { content }
+
+    public static func buildBlock<each C: ToolbarContent>(_ content: repeat each C) -> some ToolbarContent {
+        var parts: [any ToolbarContent] = []
+        for part in repeat each content { parts.append(part) }
+        return _ToolbarContentList(parts: parts)
+    }
+
+    public static func buildExpression<C: ToolbarContent>(_ content: C) -> C { content }
+
+    public static func buildOptional<C: ToolbarContent>(_ content: C?) -> some ToolbarContent {
+        _ToolbarContentList(parts: content.map { [$0] } ?? [])
+    }
+
+    public static func buildEither<T: ToolbarContent>(first: T) -> some ToolbarContent {
+        _ToolbarContentList(parts: [first])
+    }
+
+    public static func buildEither<F: ToolbarContent>(second: F) -> some ToolbarContent {
+        _ToolbarContentList(parts: [second])
+    }
+
+    public static func buildIf<C: ToolbarContent>(_ content: C?) -> some ToolbarContent {
+        _ToolbarContentList(parts: content.map { [$0] } ?? [])
+    }
+}
+
+/// The content plus its toolbar groups, as sibling children. The groups are
+/// hoisted to the enclosing `navscreen` when elements are emitted.
+struct _ToolbarView<Content: View> {
+    let content: Content
+    let groups: [any View]
+}
+extension _ToolbarView: _PrimitiveView {}
+extension _ToolbarView: _GroupView {
+    var _children: [any View] { [content] + groups }
+}
+
+extension View {
+    public func toolbar<C: ToolbarContent>(@ToolbarContentBuilder content: () -> C) -> some View {
+        _ToolbarView(content: self, groups: content()._toolbarItems)
+    }
+
+    /// Plain views in a toolbar go to the trailing placement.
+    public func toolbar<V: View>(@ViewBuilder content: () -> V) -> some View {
+        _ToolbarView(content: self, groups: [_ToolbarGroupView(placement: .automatic, items: [content()])])
+    }
+
+    public func toolbar(_ visibility: Visibility, for bars: ToolbarPlacement...) -> some View { self }
+    public func toolbarBackground<S: ShapeStyle>(_ style: S, for bars: ToolbarPlacement...) -> some View { self }
+    public func toolbarBackground(_ visibility: Visibility, for bars: ToolbarPlacement...) -> some View { self }
+    public func toolbarColorScheme(_ colorScheme: ColorScheme?, for bars: ToolbarPlacement...) -> some View { self }
+}
+
+public enum Visibility: Hashable, Sendable { case automatic, visible, hidden }
+
+public struct ToolbarPlacement: Hashable, Sendable {
+    let name: String
+    public static let automatic = ToolbarPlacement(name: "automatic")
+    public static let navigationBar = ToolbarPlacement(name: "navigationBar")
+    public static let tabBar = ToolbarPlacement(name: "tabBar")
+    public static let bottomBar = ToolbarPlacement(name: "bottomBar")
+}
+
+// MARK: - Searchable
+
+/// A `searchfield` element bound to the search text; hoisted into the bar.
+struct _SearchFieldView {
+    let text: Binding<String>
+    let prompt: String
+}
+extension _SearchFieldView: _PrimitiveView {}
+extension _SearchFieldView: _HostView {
+    var _kind: String { "searchfield" }
+    func _props(in environment: EnvironmentValues) -> _JSON {
+        .object(["text": .string(text.wrappedValue), "placeholder": .string(prompt)])
+    }
+    var _handler: ((_JSON) -> Void)? {
+        let text = self.text
+        return { payload in
+            if case .string(let value) = payload { text.wrappedValue = value }
+        }
+    }
+}
+
+struct _SearchableView<Content: View> {
+    let content: Content
+    let field: _SearchFieldView
+}
+extension _SearchableView: _PrimitiveView {}
+extension _SearchableView: _GroupView {
+    var _children: [any View] { [content, field] }
+}
+
+public struct SearchFieldPlacement: Hashable, Sendable {
+    let name: String
+    public static let automatic = SearchFieldPlacement(name: "automatic")
+    public static let toolbar = SearchFieldPlacement(name: "toolbar")
+    public static let sidebar = SearchFieldPlacement(name: "sidebar")
+    public static let navigationBarDrawer = SearchFieldPlacement(name: "navigationBarDrawer")
+}
+
+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"))
+    }
+
+    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)))
+    }
+
+    public func searchable(text: Binding<String>, placement: SearchFieldPlacement = .automatic,
+                           prompt: LocalizedStringKey) -> some View {
+        _SearchableView(content: self, field: _SearchFieldView(text: text, prompt: prompt.key))
+    }
+}

package/Sources/SwiftUI/API/View.swift

@@ -0,0 +1,207 @@
+/// A type that represents part of your app's user interface.
+///
+/// Mirrors SwiftUI's declaration, including main-actor isolation, so that a
+/// type conforming to `View` in its primary declaration is main-actor
+/// isolated on every platform.
+@MainActor @preconcurrency
+public protocol View {
+    associatedtype Body: View
+    @ViewBuilder var body: Self.Body { get }
+}
+
+extension Never: View {
+    public typealias Body = Never
+    public var body: Never { fatalError("Never has no body") }
+}
+
+/// Views the runtime renders directly instead of evaluating `body`.
+public protocol _PrimitiveView: View where Body == Never {}
+
+extension _PrimitiveView {
+    public var body: Never {
+        fatalError("\(Self.self) is a primitive view and has no body")
+    }
+}
+
+/// A view whose only job is to contribute other views to its parent.
+/// Tuples, optionals, conditionals, `Group`, `AnyView` and `ForEach` are groups.
+protocol _GroupView {
+    var _children: [any View] { get }
+    /// Stable identities for `_children`, when the group is keyed (`ForEach`).
+    var _keys: [AnyHashable]? { get }
+}
+
+extension _GroupView {
+    var _keys: [AnyHashable]? { nil }
+}
+
+/// A view that becomes an element in the render tree (see docs/ops-protocol.md).
+protocol _HostView {
+    var _kind: String { get }
+    func _props(in environment: EnvironmentValues) -> _JSON
+    var _content: [any View] { get }
+    /// Receives the event payload (`.null` for a tap).
+    var _handler: ((_JSON) -> Void)? { get }
+}
+
+extension _HostView {
+    var _content: [any View] { [] }
+    var _handler: ((_JSON) -> Void)? { nil }
+}
+
+// MARK: - ViewBuilder
+
+@resultBuilder
+public enum ViewBuilder {
+    public static func buildBlock() -> EmptyView { EmptyView() }
+
+    public static func buildBlock<Content: View>(_ content: Content) -> Content { content }
+
+    public static func buildBlock<each Content: View>(
+        _ content: repeat each Content
+    ) -> TupleView<(repeat each Content)> {
+        var children: [any View] = []
+        for child in repeat each content { children.append(child) }
+        return TupleView((repeat each content), children: children)
+    }
+
+    public static func buildExpression<Content: View>(_ content: Content) -> Content { content }
+
+    public static func buildOptional<Content: View>(_ content: Content?) -> Content? { content }
+
+    public static func buildEither<TrueContent: View, FalseContent: View>(
+        first: TrueContent
+    ) -> _ConditionalContent<TrueContent, FalseContent> {
+        _ConditionalContent(storage: .trueContent(first))
+    }
+
+    public static func buildEither<TrueContent: View, FalseContent: View>(
+        second: FalseContent
+    ) -> _ConditionalContent<TrueContent, FalseContent> {
+        _ConditionalContent(storage: .falseContent(second))
+    }
+
+    public static func buildLimitedAvailability<Content: View>(_ content: Content) -> AnyView {
+        AnyView(content)
+    }
+}
+
+// MARK: - Structural views
+
+public struct EmptyView: Sendable {
+    public init() {}
+}
+extension EmptyView: _PrimitiveView {}
+extension EmptyView: _GroupView {
+    var _children: [any View] { [] }
+}
+
+public struct TupleView<T> {
+    public var value: T
+    let children: [any View]
+
+    init(_ value: T, children: [any View]) {
+        self.value = value
+        self.children = children
+    }
+}
+extension TupleView: _PrimitiveView {}
+extension TupleView: _GroupView {
+    var _children: [any View] { children }
+}
+
+public struct _ConditionalContent<TrueContent: View, FalseContent: View> {
+    enum Storage {
+        case trueContent(TrueContent)
+        case falseContent(FalseContent)
+    }
+    let storage: Storage
+}
+extension _ConditionalContent: _PrimitiveView {}
+extension _ConditionalContent: _GroupView {
+    var _children: [any View] {
+        switch storage {
+        case .trueContent(let view): [view]
+        case .falseContent(let view): [view]
+        }
+    }
+}
+
+extension Optional: View where Wrapped: View {
+    public typealias Body = Never
+    public var body: Never { fatalError("Optional is a primitive view and has no body") }
+}
+extension Optional: _GroupView where Wrapped: View {
+    var _children: [any View] {
+        switch self {
+        case .some(let view): [view]
+        case .none: []
+        }
+    }
+}
+
+/// A type-erased view.
+public struct AnyView {
+    let storage: any View
+
+    public init<V: View>(_ view: V) { storage = view }
+    public init<V: View>(erasing view: V) { storage = view }
+}
+extension AnyView: _PrimitiveView {}
+extension AnyView: _GroupView {
+    var _children: [any View] { [storage] }
+}
+
+/// Collects views without affecting layout.
+public struct Group<Content: View> {
+    let content: Content
+    public init(@ViewBuilder content: () -> Content) { self.content = content() }
+}
+extension Group: _PrimitiveView {}
+extension Group: _GroupView {
+    var _children: [any View] { [content] }
+}
+
+/// A view that computes views on demand from a collection, keyed by identity.
+/// `Content` is unconstrained so that the same type can produce chart content
+/// (`ForEach` inside a `Chart`, see Charts/ChartContent.swift); the `View`
+/// conformance applies when `Content` is a view.
+public struct ForEach<Data: RandomAccessCollection, ID: Hashable, Content> {
+    public let data: Data
+    let id: (Data.Element) -> ID
+    let content: (Data.Element) -> Content
+
+    init(_data data: Data, id: @escaping (Data.Element) -> ID, content: @escaping (Data.Element) -> Content) {
+        self.data = data
+        self.id = id
+        self.content = content
+    }
+}
+
+extension ForEach where Content: View {
+    public init(_ data: Data, id: KeyPath<Data.Element, ID>,
+                @ViewBuilder content: @escaping (Data.Element) -> Content) {
+        self.init(_data: data, id: { $0[keyPath: id] }, content: content)
+    }
+}
+
+extension ForEach where Content: View, Data.Element: Identifiable, ID == Data.Element.ID {
+    public init(_ data: Data, @ViewBuilder content: @escaping (Data.Element) -> Content) {
+        self.init(_data: data, id: { $0.id }, content: content)
+    }
+}
+
+extension ForEach where Content: View, Data == Range<Int>, ID == Int {
+    public init(_ data: Range<Int>, @ViewBuilder content: @escaping (Int) -> Content) {
+        self.init(_data: data, id: { $0 }, content: content)
+    }
+}
+
+extension ForEach: View where Content: View {
+    public typealias Body = Never
+}
+extension ForEach: _PrimitiveView where Content: View {}
+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

@@ -0,0 +1,40 @@
+/// A reusable modifier: `body(content:)` wraps the view it is applied to.
+/// `@State` and `@Environment` properties declared on a modifier are managed
+/// by the runtime like a view's (it reflects into the modifier of a
+/// `ModifiedContent`).
+@MainActor @preconcurrency
+public protocol ViewModifier {
+    associatedtype Body: View
+    typealias Content = _ViewModifier_Content<Self>
+    @ViewBuilder func body(content: Content) -> Body
+}
+
+/// The view a modifier's `body(content:)` receives: the modified view, erased.
+public struct _ViewModifier_Content<Modifier: ViewModifier> {
+    let view: AnyView
+}
+extension _ViewModifier_Content: _PrimitiveView {}
+extension _ViewModifier_Content: _GroupView {
+    var _children: [any View] { [view] }
+}
+
+/// A view with a `ViewModifier` applied.
+public struct ModifiedContent<Content: View, Modifier: ViewModifier>: View {
+    public var content: Content
+    public var modifier: Modifier
+
+    public init(content: Content, modifier: Modifier) {
+        self.content = content
+        self.modifier = modifier
+    }
+
+    public var body: some View {
+        modifier.body(content: _ViewModifier_Content(view: AnyView(content)))
+    }
+}
+
+extension View {
+    public func modifier<M: ViewModifier>(_ modifier: M) -> ModifiedContent<Self, M> {
+        ModifiedContent(content: self, modifier: modifier)
+    }
+}