@swiftbrowser/swift 0.0.0-stage → 0.2.0

package/Sources/SwiftUI/API/Picker.swift

@@ -0,0 +1,185 @@
+// MARK: - Picker styles
+
+public protocol PickerStyle {
+    var _name: String { get }
+}
+public struct DefaultPickerStyle: PickerStyle {
+    public init() {}
+    public var _name: String { "menu" }
+}
+public struct SegmentedPickerStyle: PickerStyle {
+    public init() {}
+    public var _name: String { "segmented" }
+}
+public struct MenuPickerStyle: PickerStyle {
+    public init() {}
+    public var _name: String { "menu" }
+}
+public struct InlinePickerStyle: PickerStyle {
+    public init() {}
+    public var _name: String { "inline" }
+}
+public struct WheelPickerStyle: PickerStyle {
+    public init() {}
+    public var _name: String { "menu" }
+}
+extension PickerStyle where Self == DefaultPickerStyle {
+    public static var automatic: DefaultPickerStyle { DefaultPickerStyle() }
+}
+extension PickerStyle where Self == SegmentedPickerStyle {
+    public static var segmented: SegmentedPickerStyle { SegmentedPickerStyle() }
+}
+extension PickerStyle where Self == MenuPickerStyle {
+    public static var menu: MenuPickerStyle { MenuPickerStyle() }
+}
+extension PickerStyle where Self == InlinePickerStyle {
+    public static var inline: InlinePickerStyle { InlinePickerStyle() }
+}
+extension PickerStyle where Self == WheelPickerStyle {
+    public static var wheel: WheelPickerStyle { WheelPickerStyle() }
+}
+
+nonisolated extension View {
+    public func pickerStyle<S: PickerStyle>(_ style: S) -> some View {
+        environment(\._pickerStyle, style._name)
+    }
+}
+
+enum _PickerStyleKey: EnvironmentKey { static let defaultValue = "menu" }
+enum _ListStyleKey: EnvironmentKey { static let defaultValue = "insetGrouped" }
+
+extension EnvironmentValues {
+    var _pickerStyle: String {
+        get { self[_PickerStyleKey.self] }
+        set { self[_PickerStyleKey.self] = newValue }
+    }
+
+    var _listStyle: String {
+        get { self[_ListStyleKey.self] }
+        set { self[_ListStyleKey.self] = newValue }
+    }
+}
+
+// MARK: - Picker
+
+protocol _PickerHost: _TraitBearing {
+    var _labelView: any View { get }
+    var _options: any View { get }
+    func _selectedIndex(tags: [AnyHashable?]) -> Int
+    func _select(index: Int, tags: [AnyHashable?])
+}
+
+/// A control for selecting one of several options. Options are the content's
+/// children; each option's label is its text, and its identity is its `tag`
+/// (or its `ForEach` id).
+public struct Picker<Label: View, SelectionValue: Hashable, Content: View> {
+    let label: any View
+    let selection: Binding<SelectionValue>
+    let content: Content
+
+    public init(selection: Binding<SelectionValue>, @ViewBuilder content: () -> Content,
+                @ViewBuilder label: () -> Label) {
+        self.label = label()
+        self.selection = selection
+        self.content = content()
+    }
+}
+
+extension Picker where Label == Text {
+    public init(_ titleKey: LocalizedStringKey, selection: Binding<SelectionValue>, @ViewBuilder content: () -> Content) {
+        self.label = Text(titleKey)
+        self.selection = selection
+        self.content = content()
+    }
+
+    @_disfavoredOverload
+    public init<S: StringProtocol>(_ title: S, selection: Binding<SelectionValue>,
+                                   @ViewBuilder content: () -> Content) {
+        self.label = Text(title)
+        self.selection = selection
+        self.content = content()
+    }
+}
+
+extension Picker: _PrimitiveView {}
+extension Picker: _HostView {
+    var _kind: String { "picker" }
+    func _props(in environment: EnvironmentValues) -> _JSON { .object([:]) }
+    // Options, selection and the handler are produced by the runtime.
+}
+extension Picker: _PickerHost {
+    var _labelView: any View { label }
+    var _options: any View { content }
+
+    func _selectedIndex(tags: [AnyHashable?]) -> Int {
+        let current = AnyHashable(selection.wrappedValue)
+        return tags.firstIndex { $0 == current } ?? 0
+    }
+
+    func _select(index: Int, tags: [AnyHashable?]) {
+        guard index < tags.count, let tag = tags[index], let value = tag.base as? SelectionValue else { return }
+        selection.wrappedValue = value
+    }
+}
+
+/// The plain text of a label view: the first `Text` found, if any.
+@MainActor
+func _textContent(of view: any View) -> String {
+    if let text = view as? Text { return text.content }
+    if let text = view as? _PlainText { return text.content }
+    if let text = view as? _RichText { return text.text.content }
+    if let label = view as? any _TabItemProviding { return _textContent(of: label._tabLabel) }
+    if let tagged = view as? any _TagProviding { return _textContent(of: tagged._tagged) }
+    if let group = view as? any _GroupView {
+        for child in group._children {
+            let text = _textContent(of: child)
+            if !text.isEmpty { return text }
+        }
+        return ""
+    }
+    if let host = view as? any _HostView {
+        for child in host._content {
+            let text = _textContent(of: child)
+            if !text.isEmpty { return text }
+        }
+        return ""
+    }
+    func open<V: View>(_ view: V) -> any View { view.body }
+    return _textContent(of: open(view))
+}
+
+/// The first system image name in a label view, if any.
+@MainActor
+func _systemImage(of view: any View) -> String? {
+    if let image = view as? Image { return image.systemName }
+    if let label = view as? any _TabItemProviding { return _systemImage(of: label._tabLabel) }
+    if let tagged = view as? any _TagProviding { return _systemImage(of: tagged._tagged) }
+    if let group = view as? any _GroupView {
+        for child in group._children {
+            if let name = _systemImage(of: child) { return name }
+        }
+        return nil
+    }
+    if let host = view as? any _HostView {
+        for child in host._content {
+            if let name = _systemImage(of: child) { return name }
+        }
+        return nil
+    }
+    func open<V: View>(_ view: V) -> any View { view.body }
+    return _systemImage(of: open(view))
+}
+
+// MARK: - Form
+
+/// A container for grouped controls, drawn as a grouped list.
+public struct Form<Content: View> {
+    let content: Content
+    public init(@ViewBuilder content: () -> Content) { self.content = content() }
+}
+extension Form: _PrimitiveView {}
+extension Form: _HostView {
+    var _kind: String { "list" }
+    func _props(in environment: EnvironmentValues) -> _JSON { .object(["style": .string("grouped")]) }
+    var _content: [any View] { [content] }
+}

package/Sources/SwiftUI/API/PointerAndKeyboard.swift

@@ -0,0 +1,77 @@
+// Pointer and hardware-keyboard modifiers of iPad and Mac apps. The page
+// shows an iPhone: there is no hover, no tooltip and no command key, so these
+// are accepted and do nothing (`onHover` never calls its action, as on an
+// iPhone).
+
+public struct KeyEquivalent: Hashable, Sendable, ExpressibleByExtendedGraphemeClusterLiteral {
+    public let character: Character
+    public init(_ character: Character) { self.character = character }
+    public init(extendedGraphemeClusterLiteral value: Character) { character = value }
+
+    public static let upArrow = KeyEquivalent("\u{F700}")
+    public static let downArrow = KeyEquivalent("\u{F701}")
+    public static let leftArrow = KeyEquivalent("\u{F702}")
+    public static let rightArrow = KeyEquivalent("\u{F703}")
+    public static let escape = KeyEquivalent("\u{1B}")
+    public static let delete = KeyEquivalent("\u{8}")
+    public static let deleteForward = KeyEquivalent("\u{F728}")
+    public static let home = KeyEquivalent("\u{F729}")
+    public static let end = KeyEquivalent("\u{F72B}")
+    public static let pageUp = KeyEquivalent("\u{F72C}")
+    public static let pageDown = KeyEquivalent("\u{F72D}")
+    public static let clear = KeyEquivalent("\u{F739}")
+    public static let tab = KeyEquivalent("\t")
+    public static let space = KeyEquivalent(" ")
+    public static let `return` = KeyEquivalent("\r")
+}
+
+public struct EventModifiers: OptionSet, Hashable, Sendable {
+    public let rawValue: Int
+    public init(rawValue: Int) { self.rawValue = rawValue }
+    public static let capsLock = EventModifiers(rawValue: 1 << 0)
+    public static let shift = EventModifiers(rawValue: 1 << 1)
+    public static let control = EventModifiers(rawValue: 1 << 2)
+    public static let option = EventModifiers(rawValue: 1 << 3)
+    public static let command = EventModifiers(rawValue: 1 << 4)
+    public static let numericPad = EventModifiers(rawValue: 1 << 5)
+    public static let all: EventModifiers = [.capsLock, .shift, .control, .option, .command, .numericPad]
+}
+
+public struct KeyboardShortcut: Hashable, Sendable {
+    public let key: KeyEquivalent
+    public let modifiers: EventModifiers
+    public init(_ key: KeyEquivalent, modifiers: EventModifiers = .command) {
+        self.key = key
+        self.modifiers = modifiers
+    }
+    public static let defaultAction = KeyboardShortcut(.return, modifiers: [])
+    public static let cancelAction = KeyboardShortcut(.escape, modifiers: [])
+}
+
+nonisolated extension View {
+    public func keyboardShortcut(_ key: KeyEquivalent, modifiers: EventModifiers = .command) -> some View { self }
+    public func keyboardShortcut(_ shortcut: KeyboardShortcut) -> some View { self }
+    public func keyboardShortcut(_ shortcut: KeyboardShortcut?) -> some View { self }
+
+    /// Never called: an iPhone has no pointer to hover with.
+    public func onHover(perform action: @escaping (Bool) -> Void) -> some View { self }
+
+    /// A tooltip; the page shows none.
+    public func help(_ text: Text) -> some View { self }
+    public func help(_ textKey: LocalizedStringKey) -> some View { self }
+    @_disfavoredOverload
+    public func help<S: StringProtocol>(_ text: S) -> some View { self }
+}
+
+/// The pointer effect of an iPad; the page draws none.
+public struct HoverEffect: Hashable, Sendable {
+    let name: String
+    public static let automatic = HoverEffect(name: "automatic")
+    public static let highlight = HoverEffect(name: "highlight")
+    public static let lift = HoverEffect(name: "lift")
+}
+
+nonisolated extension View {
+    public func hoverEffect(_ effect: HoverEffect = .automatic, isEnabled: Bool = true) -> some View { self }
+    public func hoverEffectDisabled(_ disabled: Bool = true) -> some View { self }
+}

package/Sources/SwiftUI/API/Popover.swift

@@ -0,0 +1,41 @@
+// `.popover`: on an iPhone (a compact width) a popover is presented as a
+// sheet, so here it is one: the same `sheet` element `.sheet` makes. The
+// attachment anchor and arrow edge are accepted;
+// `.presentationCompactAdaptation(_:)` is accepted and changes nothing
+// (a popover never draws as a bubble).
+
+public enum PopoverAttachmentAnchor {
+    case rect(Anchor<CGRect>.Source)
+    case point(UnitPoint)
+}
+
+public struct PresentationAdaptation: Hashable, Sendable {
+    let name: String
+    public static let automatic = PresentationAdaptation(name: "automatic")
+    public static let none = PresentationAdaptation(name: "none")
+    public static let popover = PresentationAdaptation(name: "popover")
+    public static let sheet = PresentationAdaptation(name: "sheet")
+    public static let fullScreenCover = PresentationAdaptation(name: "fullScreenCover")
+}
+
+extension View {
+    public func popover<Content: View>(isPresented: Binding<Bool>,
+                                       attachmentAnchor: PopoverAttachmentAnchor = .rect(.bounds),
+                                       arrowEdge: Edge? = nil,
+                                       @ViewBuilder content: @escaping () -> Content) -> some View {
+        sheet(isPresented: isPresented, content: content)
+    }
+
+    public func popover<Item: Identifiable, Content: View>(item: Binding<Item?>,
+                                                           attachmentAnchor: PopoverAttachmentAnchor = .rect(.bounds),
+                                                           arrowEdge: Edge? = nil,
+                                                           @ViewBuilder content: @escaping (Item) -> Content) -> some View {
+        sheet(item: item, content: content)
+    }
+}
+
+nonisolated extension View {
+    public func presentationCompactAdaptation(_ adaptation: PresentationAdaptation) -> some View { self }
+    public func presentationCompactAdaptation(horizontal: PresentationAdaptation,
+                                              vertical: PresentationAdaptation) -> some View { self }
+}

package/Sources/SwiftUI/API/Preferences.swift

@@ -0,0 +1,262 @@
+// Preferences: values views pass up to their ancestors, the way environment
+// values pass down. A view sets one with `.preference(key:value:)`; the
+// reconciler combines a subtree's values with the key's `reduce` (children in
+// order) after the subtree's bodies ran, and `.onPreferenceChange`,
+// `.overlayPreferenceValue` and `.backgroundPreferenceValue` read the result.
+// A subtree that is skipped keeps the values it produced last time.
+//
+// Anchors: the Swift side has no layout, so an anchor resolves against the
+// size the renderer reports for the anchored view (its element carries
+// `reportsSize`, like a `GeometryReader`'s), in the view's own coordinates:
+// `.bounds` is `CGRect(origin: .zero, size: measured)`. Until the first
+// report it is zero, and the preference updates when the size arrives.
+
+/// A named value produced by a view, combined over a subtree with `reduce`.
+public protocol PreferenceKey {
+    associatedtype Value
+    static var defaultValue: Value { get }
+    static func reduce(value: inout Value, nextValue: () -> Value)
+}
+
+extension PreferenceKey where Value: ExpressibleByNilLiteral {
+    public static var defaultValue: Value { nil }
+}
+
+/// The preference values a subtree produced, by key type.
+struct _PreferenceValues {
+    struct Entry {
+        var value: Any
+        /// The key's `reduce`, for combining with a later sibling's value.
+        let reduce: (Any, Any) -> Any
+    }
+
+    var entries: [ObjectIdentifier: Entry] = [:]
+
+    var isEmpty: Bool { entries.isEmpty }
+
+    subscript<K: PreferenceKey>(key: K.Type) -> K.Value? {
+        entries[ObjectIdentifier(key)]?.value as? K.Value
+    }
+
+    /// The key's combined value, or its default when nothing in the subtree set it.
+    func value<K: PreferenceKey>(of key: K.Type) -> K.Value { self[key] ?? K.defaultValue }
+
+    mutating func set<K: PreferenceKey>(_ key: K.Type, to value: K.Value) {
+        entries[ObjectIdentifier(key)] = Entry(value: value) { first, next in
+            var combined = first as! K.Value
+            K.reduce(value: &combined) { next as! K.Value }
+            return combined
+        }
+    }
+
+    mutating func remove<K: PreferenceKey>(_ key: K.Type) {
+        entries[ObjectIdentifier(key)] = nil
+    }
+
+    /// Adds a later sibling's values: a key both set is reduced, in order.
+    mutating func merge(_ later: _PreferenceValues) {
+        for (key, entry) in later.entries {
+            if var existing = entries[key] {
+                existing.value = existing.reduce(existing.value, entry.value)
+                entries[key] = existing
+            } else {
+                entries[key] = entry
+            }
+        }
+    }
+}
+
+/// A view that changes its subtree's preference values (after its children's are combined).
+protocol _PreferenceWriting: _TraitBearing {
+    func _write(_ values: inout _PreferenceValues, measured: CGSize)
+}
+
+/// A view that reads its subtree's combined values.
+protocol _PreferenceReading: _TraitBearing {
+    /// Called after the subtree reconciled; `last` is what the previous call returned.
+    @MainActor func _read(_ values: _PreferenceValues, last: Any?) -> (keep: Any?, action: (@MainActor () -> Void)?)
+}
+
+/// A view whose element reports its laid-out size (`reportsSize`).
+protocol _SizeReporting: _TraitBearing {}
+
+/// `overlayPreferenceValue` / `backgroundPreferenceValue`: the decoration is
+/// made from the base's combined value, after the base reconciled.
+protocol _PreferenceValueDecorating: _TraitBearing {
+    var _base: any View { get }
+    func _decoration(from values: _PreferenceValues) -> any View
+}
+
+// MARK: - Setting
+
+struct _PreferenceView<Content: View, Key: PreferenceKey> {
+    let content: Content
+    let value: Key.Value
+}
+extension _PreferenceView: _PrimitiveView, _GroupView {
+    var _children: [any View] { [content] }
+}
+extension _PreferenceView: _PreferenceWriting {
+    func _write(_ values: inout _PreferenceValues, measured: CGSize) { values.set(Key.self, to: value) }
+}
+
+struct _TransformPreferenceView<Content: View, Key: PreferenceKey> {
+    let content: Content
+    let transform: (inout Key.Value) -> Void
+}
+extension _TransformPreferenceView: _PrimitiveView, _GroupView {
+    var _children: [any View] { [content] }
+}
+extension _TransformPreferenceView: _PreferenceWriting {
+    func _write(_ values: inout _PreferenceValues, measured: CGSize) {
+        var value = values.value(of: Key.self)
+        transform(&value)
+        values.set(Key.self, to: value)
+    }
+}
+
+nonisolated extension View {
+    /// Sets the key's value for this view; it replaces what the content set for the key.
+    public func preference<K: PreferenceKey>(key: K.Type = K.self, value: K.Value) -> some View {
+        _PreferenceView<Self, K>(content: self, value: value)
+    }
+
+    /// Changes the key's value the content produced (its default when it set none).
+    public func transformPreference<K: PreferenceKey>(_ key: K.Type = K.self, _ callback: @escaping (inout K.Value) -> Void) -> some View {
+        _TransformPreferenceView<Self, K>(content: self, transform: callback)
+    }
+}
+
+// MARK: - Reading
+
+struct _PreferenceChangeView<Content: View, Key: PreferenceKey> where Key.Value: Equatable {
+    let content: Content
+    let action: (Key.Value) -> Void
+}
+extension _PreferenceChangeView: _PrimitiveView, _GroupView {
+    var _children: [any View] { [content] }
+}
+extension _PreferenceChangeView: _PreferenceReading {
+    @MainActor func _read(_ values: _PreferenceValues, last: Any?) -> (keep: Any?, action: (@MainActor () -> Void)?) {
+        let value = values.value(of: Key.self)
+        if let last = last as? Key.Value, last == value { return (last, nil) }
+        let action = self.action
+        return (value, { action(value) })
+    }
+}
+
+struct _PreferenceDecorationView<Content: View, Key: PreferenceKey, Decoration: View> {
+    let content: Content
+    let decoration: (Key.Value) -> Decoration
+    let role: String
+    let alignment: Alignment
+}
+extension _PreferenceDecorationView: _PrimitiveView {}
+extension _PreferenceDecorationView: _HostView {
+    var _kind: String { "decorated" }
+    func _props(in environment: EnvironmentValues) -> _JSON {
+        .object(["role": .string(role), "alignment": .string(alignment._name)])
+    }
+    var _content: [any View] { [content] }
+}
+extension _PreferenceDecorationView: _PreferenceValueDecorating {
+    var _base: any View { content }
+    func _decoration(from values: _PreferenceValues) -> any View { decoration(values.value(of: Key.self)) }
+}
+
+nonisolated extension View {
+    /// Runs `action` after a render in which the key's combined value in this
+    /// subtree changed (and after the first, with its initial value).
+    public func onPreferenceChange<K: PreferenceKey>(_ key: K.Type = K.self, perform action: @escaping (K.Value) -> Void) -> some View where K.Value: Equatable {
+        _PreferenceChangeView<Self, K>(content: self, action: action)
+    }
+
+    /// An overlay made from the key's combined value in this view.
+    public func overlayPreferenceValue<K: PreferenceKey, V: View>(_ key: K.Type, alignment: Alignment = .center, @ViewBuilder _ transform: @escaping (K.Value) -> V) -> some View {
+        _PreferenceDecorationView<Self, K, V>(content: self, decoration: transform, role: "overlay", alignment: alignment)
+    }
+
+    /// A background made from the key's combined value in this view.
+    public func backgroundPreferenceValue<K: PreferenceKey, V: View>(_ key: K.Type, alignment: Alignment = .center, @ViewBuilder _ transform: @escaping (K.Value) -> V) -> some View {
+        _PreferenceDecorationView<Self, K, V>(content: self, decoration: transform, role: "background", alignment: alignment)
+    }
+}
+
+// MARK: - Anchors
+
+/// A geometric value of a view, resolved with a `GeometryProxy` subscript.
+public struct Anchor<Value> {
+    let value: Value
+
+    /// How to make an anchor from a view's bounds.
+    public struct Source {
+        let resolve: (CGRect) -> Value
+    }
+}
+extension Anchor: Equatable where Value: Equatable {}
+extension Anchor: Hashable where Value: Hashable {}
+extension Anchor: Sendable where Value: Sendable {}
+
+extension Anchor.Source where Value == CGRect {
+    public static var bounds: Anchor<CGRect>.Source { .init { $0 } }
+    public static func rect(_ r: CGRect) -> Anchor<CGRect>.Source { .init { _ in r } }
+}
+
+extension Anchor.Source where Value == CGPoint {
+    public static func point(_ p: CGPoint) -> Anchor<CGPoint>.Source { .init { _ in p } }
+    public static func unitPoint(_ p: UnitPoint) -> Anchor<CGPoint>.Source {
+        .init { CGPoint(x: $0.minX + p.x * $0.width, y: $0.minY + p.y * $0.height) }
+    }
+    public static var topLeading: Anchor<CGPoint>.Source { unitPoint(.topLeading) }
+    public static var top: Anchor<CGPoint>.Source { unitPoint(.top) }
+    public static var topTrailing: Anchor<CGPoint>.Source { unitPoint(.topTrailing) }
+    public static var leading: Anchor<CGPoint>.Source { unitPoint(.leading) }
+    public static var center: Anchor<CGPoint>.Source { unitPoint(.center) }
+    public static var trailing: Anchor<CGPoint>.Source { unitPoint(.trailing) }
+    public static var bottomLeading: Anchor<CGPoint>.Source { unitPoint(.bottomLeading) }
+    public static var bottom: Anchor<CGPoint>.Source { unitPoint(.bottom) }
+    public static var bottomTrailing: Anchor<CGPoint>.Source { unitPoint(.bottomTrailing) }
+}
+
+extension GeometryProxy {
+    /// The anchor's value, in the anchored view's own coordinates (see the file comment).
+    public subscript<T>(anchor: Anchor<T>) -> T { anchor.value }
+}
+
+struct _AnchorPreferenceView<Content: View, A, Key: PreferenceKey> {
+    let content: Content
+    let source: Anchor<A>.Source
+    /// Sets the value (`anchorPreference`) or changes it (`transformAnchorPreference`).
+    let write: (inout _PreferenceValues, Anchor<A>) -> Void
+}
+extension _AnchorPreferenceView: _PrimitiveView, _SizeReporting {}
+extension _AnchorPreferenceView: _HostView {
+    var _kind: String { "zstack" }
+    func _props(in environment: EnvironmentValues) -> _JSON {
+        .object(["alignment": .string(Alignment.center._name), "reportsSize": .bool(true)])
+    }
+    var _content: [any View] { [content] }
+}
+extension _AnchorPreferenceView: _PreferenceWriting {
+    func _write(_ values: inout _PreferenceValues, measured: CGSize) {
+        write(&values, Anchor(value: source.resolve(CGRect(origin: .zero, size: measured))))
+    }
+}
+
+nonisolated extension View {
+    /// Sets the key's value from an anchor of this view's bounds.
+    public func anchorPreference<A, K: PreferenceKey>(key: K.Type = K.self, value: Anchor<A>.Source, transform: @escaping (Anchor<A>) -> K.Value) -> some View {
+        _AnchorPreferenceView<Self, A, K>(content: self, source: value) { values, anchor in
+            values.set(K.self, to: transform(anchor))
+        }
+    }
+
+    /// Changes the key's value with an anchor of this view's bounds.
+    public func transformAnchorPreference<A, K: PreferenceKey>(key: K.Type = K.self, value: Anchor<A>.Source, transform: @escaping (inout K.Value, Anchor<A>) -> Void) -> some View {
+        _AnchorPreferenceView<Self, A, K>(content: self, source: value) { values, anchor in
+            var current = values.value(of: K.self)
+            transform(&current, anchor)
+            values.set(K.self, to: current)
+        }
+    }
+}

package/Sources/SwiftUI/API/Presentation.swift

@@ -0,0 +1,122 @@
+/// A height a sheet can rest at.
+public struct PresentationDetent: Hashable, Sendable {
+    let name: String
+    public static let medium = PresentationDetent(name: "medium")
+    public static let large = PresentationDetent(name: "large")
+    /// A sheet this many points tall (`"height:<points>"`, capped at the large height).
+    public static func height(_ height: CGFloat) -> PresentationDetent { PresentationDetent(name: "height:\(Double(height))") }
+    /// A sheet this fraction of the screen tall (`"fraction:<f>"`, capped at the large height).
+    public static func fraction(_ fraction: CGFloat) -> PresentationDetent { PresentationDetent(name: "fraction:\(Double(fraction))") }
+
+    /// Orders detents smallest first (a height counts against an 852pt screen).
+    var _order: Double {
+        if name == "medium" { return 0.5 }
+        if name.hasPrefix("height:") { return (Double(name.dropFirst(7)) ?? 852) / 852 }
+        if name.hasPrefix("fraction:") { return Double(name.dropFirst(9)) ?? 1 }
+        return 1
+    }
+}
+
+/// Views that present a sheet. The runtime mounts the sheet content as a
+/// second child and emits it as a root-level `sheet` element while presented.
+protocol _SheetPresenting: _TraitBearing {
+    var _isPresented: Binding<Bool> { get }
+    var _onDismiss: (@MainActor () -> Void)? { get }
+    var _base: any View { get }
+    var _sheetContent: any View { get }
+    /// `.fullScreenCover`: the sheet's detents are `["full"]`.
+    var _fullScreen: Bool { get }
+}
+
+struct _SheetView<Base: View, Content: View> {
+    let base: Base
+    let isPresented: Binding<Bool>
+    let onDismiss: (@MainActor () -> Void)?
+    let content: Content
+    var fullScreen = false
+}
+extension _SheetView: _PrimitiveView {}
+extension _SheetView: _GroupView {
+    // Only the base is a regular child; the runtime adds the sheet content.
+    var _children: [any View] { [base] }
+}
+extension _SheetView: _SheetPresenting {
+    var _isPresented: Binding<Bool> { isPresented }
+    var _onDismiss: (@MainActor () -> Void)? { onDismiss }
+    var _base: any View { base }
+    var _sheetContent: any View { content }
+    var _fullScreen: Bool { fullScreen }
+}
+
+protocol _DetentsModifying: _TraitBearing {
+    var _detents: [String] { get }
+}
+
+struct _DetentsView<Content: View> {
+    let content: Content
+    let detents: [String]
+}
+extension _DetentsView: _PrimitiveView {}
+extension _DetentsView: _GroupView {
+    var _children: [any View] { [content] }
+}
+extension _DetentsView: _DetentsModifying {
+    var _detents: [String] { detents }
+}
+
+extension View {
+    /// Presents a sheet when `isPresented` is true.
+    public func sheet<Content: View>(isPresented: Binding<Bool>,
+                                     onDismiss: (@MainActor () -> Void)? = nil,
+                                     @ViewBuilder content: () -> Content) -> some View {
+        _SheetView(base: self, isPresented: isPresented, onDismiss: onDismiss, content: content())
+    }
+
+    /// Presents a sheet for a non-nil item; dismissing sets it back to nil.
+    public func sheet<Item: Identifiable, Content: View>(item: Binding<Item?>,
+                                                         onDismiss: (@MainActor () -> Void)? = nil,
+                                                         @ViewBuilder content: @escaping (Item) -> Content) -> some View {
+        let isPresented = Binding<Bool>(
+            get: { item.wrappedValue != nil },
+            set: { if !$0 { item.wrappedValue = nil } }
+        )
+        return _SheetView(base: self, isPresented: isPresented, onDismiss: onDismiss,
+                          content: _ItemSheetContent(item: item, content: content))
+    }
+
+    /// Presents a sheet that fills the screen (`detents: ["full"]`).
+    public func fullScreenCover<Content: View>(isPresented: Binding<Bool>,
+                                               onDismiss: (@MainActor () -> Void)? = nil,
+                                               @ViewBuilder content: () -> Content) -> some View {
+        _SheetView(base: self, isPresented: isPresented, onDismiss: onDismiss, content: content(), fullScreen: true)
+    }
+
+    public func fullScreenCover<Item: Identifiable, Content: View>(item: Binding<Item?>,
+                                                                   onDismiss: (@MainActor () -> Void)? = nil,
+                                                                   @ViewBuilder content: @escaping (Item) -> Content) -> some View {
+        let isPresented = Binding<Bool>(
+            get: { item.wrappedValue != nil },
+            set: { if !$0 { item.wrappedValue = nil } }
+        )
+        return _SheetView(base: self, isPresented: isPresented, onDismiss: onDismiss,
+                          content: _ItemSheetContent(item: item, content: content), fullScreen: true)
+    }
+
+    public func presentationDetents(_ detents: Set<PresentationDetent>) -> some View {
+        // Smallest first: the page presents the sheet at the first.
+        let sorted = detents.sorted { ($0._order, $0.name) < ($1._order, $1.name) }
+        return _DetentsView(content: self, detents: sorted.map(\.name))
+    }
+}
+
+/// The content of `.sheet(item:)`, built from the current item (empty once it is nil).
+struct _ItemSheetContent<Item: Identifiable, Content: View>: View {
+    let item: Binding<Item?>
+    let content: (Item) -> Content
+
+    var body: some View {
+        if let value = item.wrappedValue {
+            content(value)
+        }
+    }
+}