@swiftbrowser/swift 0.1.0 → 0.3.0

package/Sources/SwiftUI/API/EditMode.swift

@@ -1,57 +1,15 @@
-/// Edit mode, `EditButton`, `ForEach.onDelete` / `onMove`, offset sets and
-/// `refreshable`. See docs/ops-protocol.md, "Phase 8: interaction".
+/// Edit mode, `EditButton`, `ForEach.onDelete` / `onMove` and `refreshable`.
+/// See docs/ops-protocol.md, "Phase 8: interaction".
 
-// MARK: - Offset sets
-
-/// A set of offsets into a collection, as `onDelete` / `onMove` report and
-/// `remove(atOffsets:)` / `move(fromOffsets:toOffset:)` consume. Foundation's
-/// `IndexSet` is not in FoundationEssentials, so the shim is generic over this
-/// protocol: `FoundationLite.IndexSet` conforms, and `_IndexSetLite` serves
-/// apps that import neither (it is what `onDelete` infers when nothing else
-/// pins the type).
-public protocol _OffsetSet {
-    init(_offsets: [Int])
-    /// The offsets in ascending order, without duplicates.
-    var _offsets: [Int] { get }
-}
-
-/// A minimal `IndexSet`: sorted unique integers.
-public struct _IndexSetLite: _OffsetSet, Hashable, Sendable, Sequence, ExpressibleByArrayLiteral {
-    public private(set) var _offsets: [Int]
-
-    public init(_offsets: [Int]) {
-        self._offsets = Array(Set(_offsets)).sorted()
-    }
-
-    public init() { _offsets = [] }
-    public init(integer: Int) { _offsets = [integer] }
-    public init<S: Sequence>(_ elements: S) where S.Element == Int { self.init(_offsets: Array(elements)) }
-    public init(arrayLiteral elements: Int...) { self.init(_offsets: elements) }
-    public init(integersIn range: Range<Int>) { _offsets = Array(range) }
-
-    public var count: Int { _offsets.count }
-    public var isEmpty: Bool { _offsets.isEmpty }
-    public var first: Int? { _offsets.first }
-    public var last: Int? { _offsets.last }
-    public func contains(_ integer: Int) -> Bool { _offsets.contains(integer) }
-
-    public mutating func insert(_ integer: Int) {
-        guard !contains(integer) else { return }
-        _offsets.append(integer)
-        _offsets.sort()
-    }
-
-    public mutating func remove(_ integer: Int) {
-        _offsets.removeAll { $0 == integer }
-    }
+import Foundation
 
-    public func makeIterator() -> IndexingIterator<[Int]> { _offsets.makeIterator() }
-}
+// MARK: - Offset sets
 
 extension RangeReplaceableCollection {
-    /// Removes the elements at `offsets` (offsets from `startIndex`).
-    public mutating func remove<O: _OffsetSet>(atOffsets offsets: O) {
-        for offset in offsets._offsets.sorted(by: >) where offset >= 0 && offset < count {
+    /// Removes the elements at `offsets` (offsets from `startIndex`), as
+    /// SwiftUI's `onDelete` handlers do.
+    public mutating func remove(atOffsets offsets: IndexSet) {
+        for offset in offsets.sorted(by: >) where offset >= 0 && offset < count {
             remove(at: index(startIndex, offsetBy: offset))
         }
     }
@@ -60,8 +18,8 @@ extension RangeReplaceableCollection {
 extension MutableCollection where Self: RangeReplaceableCollection {
     /// Moves the elements at `source` so that they start at `destination`
     /// (an offset into the collection before the move), like Foundation's.
-    public mutating func move<O: _OffsetSet>(fromOffsets source: O, toOffset destination: Int) {
-        let offsets = source._offsets.filter { $0 >= 0 && $0 < count }
+    public mutating func move(fromOffsets source: IndexSet, toOffset destination: Int) {
+        let offsets = source.filter { $0 >= 0 && $0 < count }
         guard !offsets.isEmpty else { return }
         let moving = offsets.map { self[index(startIndex, offsetBy: $0)] }
         let before = offsets.filter { $0 < destination }.count
@@ -86,7 +44,7 @@ extension ForEach: DynamicViewContent where Content: View {}
 
 /// A keyed group whose rows a `List` can delete (and, when the renderer learns
 /// to, move). The runtime wraps each row in a `listrow` with `deletable`.
-protocol _DeletableGroup {
+protocol _DeletableGroup: _TraitBearing {
     /// Calls the group's `onDelete` with the row at `offset`; nil without one.
     var _delete: ((Int) -> Void)? { get }
     var _move: ((Int, Int) -> Void)? { get }
@@ -104,6 +62,7 @@ extension _EditableForEach: DynamicViewContent {
 extension _EditableForEach: _GroupView {
     var _children: [any View] { (base as? any _GroupView)?._children ?? [base] }
     var _keys: [AnyHashable]? { (base as? any _GroupView)?._keys }
+    var _spreads: Bool { (base as? any _GroupView)?._spreads ?? false }
 }
 extension _EditableForEach: _DeletableGroup {
     var _delete: ((Int) -> Void)? { delete }
@@ -113,46 +72,29 @@ extension _EditableForEach: _DeletableGroup {
 extension DynamicViewContent {
     /// Lets a `List` delete the rows: `action` receives the offsets of the
     /// removed elements in `data`. Pass `nil` to opt out.
-    public func onDelete<O: _OffsetSet>(perform action: ((O) -> Void)?) -> _EditableForEach<Self> {
-        _EditableForEach(base: self, delete: action.map { action in { action(O(_offsets: [$0])) } }, move: nil)
-    }
-
-    /// The offsets default to `_IndexSetLite` when nothing else pins the type.
-    public func onDelete(perform action: ((_IndexSetLite) -> Void)?) -> _EditableForEach<Self> {
-        _EditableForEach(base: self, delete: action.map { action in { action(_IndexSetLite(_offsets: [$0])) } }, move: nil)
+    public func onDelete(perform action: ((IndexSet) -> Void)?) -> _EditableForEach<Self> {
+        _EditableForEach(base: self, delete: action.map { action in { action(IndexSet(integer: $0)) } }, move: nil)
     }
 
     /// Accepted for source compatibility; the renderer offers no reordering yet.
-    public func onMove<O: _OffsetSet>(perform action: ((O, Int) -> Void)?) -> _EditableForEach<Self> {
-        _EditableForEach(base: self, delete: nil, move: action.map { action in { action(O(_offsets: [$0]), $1) } })
-    }
-
-    public func onMove(perform action: ((_IndexSetLite, Int) -> Void)?) -> _EditableForEach<Self> {
-        _EditableForEach(base: self, delete: nil, move: action.map { action in { action(_IndexSetLite(_offsets: [$0]), $1) } })
+    public func onMove(perform action: ((IndexSet, Int) -> Void)?) -> _EditableForEach<Self> {
+        _EditableForEach(base: self, delete: nil, move: action.map { action in { action(IndexSet(integer: $0), $1) } })
     }
 }
 
 extension _EditableForEach {
     /// `ForEach(...).onDelete(...).onMove(...)`: the second modifier merges into the first.
-    public func onDelete<O: _OffsetSet>(perform action: ((O) -> Void)?) -> _EditableForEach<Base> {
-        _EditableForEach(base: base, delete: action.map { action in { action(O(_offsets: [$0])) } }, move: move)
-    }
-
-    public func onDelete(perform action: ((_IndexSetLite) -> Void)?) -> _EditableForEach<Base> {
-        _EditableForEach(base: base, delete: action.map { action in { action(_IndexSetLite(_offsets: [$0])) } }, move: move)
-    }
-
-    public func onMove<O: _OffsetSet>(perform action: ((O, Int) -> Void)?) -> _EditableForEach<Base> {
-        _EditableForEach(base: base, delete: delete, move: action.map { action in { action(O(_offsets: [$0]), $1) } })
+    public func onDelete(perform action: ((IndexSet) -> Void)?) -> _EditableForEach<Base> {
+        _EditableForEach(base: base, delete: action.map { action in { action(IndexSet(integer: $0)) } }, move: move)
     }
 
-    public func onMove(perform action: ((_IndexSetLite, Int) -> Void)?) -> _EditableForEach<Base> {
-        _EditableForEach(base: base, delete: delete, move: action.map { action in { action(_IndexSetLite(_offsets: [$0]), $1) } })
+    public func onMove(perform action: ((IndexSet, Int) -> Void)?) -> _EditableForEach<Base> {
+        _EditableForEach(base: base, delete: delete, move: action.map { action in { action(IndexSet(integer: $0), $1) } })
     }
 }
 
 /// `.deleteDisabled` / `.moveDisabled` on a row.
-protocol _RowEditingDisabling {
+protocol _RowEditingDisabling: _TraitBearing {
     var _deleteDisabled: Bool { get }
 }
 
@@ -168,7 +110,7 @@ extension _DeleteDisabledView: _RowEditingDisabling {
     var _deleteDisabled: Bool { disabled }
 }
 
-extension View {
+nonisolated extension View {
     public func deleteDisabled(_ isDisabled: Bool) -> some View {
         _DeleteDisabledView(content: self, disabled: isDisabled)
     }
@@ -228,10 +170,11 @@ extension EnvironmentValues {
     }
 }
 
-extension View {
+nonisolated extension View {
     /// Pull to refresh on the `List` or `ScrollView` this modifies: the view
     /// shows a spinner (`refreshing`) while `action` runs.
-    public func refreshable(action: @escaping @Sendable () async -> Void) -> some View {
+    /// The action runs in the caller's actor context, as `.task`'s does.
+    public func refreshable(@_inheritActorContext action: @escaping @Sendable () async -> Void) -> some View {
         environment(\._refreshAction, action)
     }
 }

package/Sources/SwiftUI/API/Effects.swift

@@ -59,7 +59,7 @@ extension Image {
     }
 }
 
-extension View {
+nonisolated extension View {
     /// Translates the rendered view without affecting layout.
     public func offset(x: CGFloat = 0, y: CGFloat = 0) -> some View {
         _styled { $0.extras["offset"] = .object(["x": .number(x), "y": .number(y)]) }
@@ -175,6 +175,13 @@ extension View {
         _styled { $0.extras["tint"] = tint?._json ?? .null }
     }
 
+    /// A style as the tint. The page tints with a color: a gradient tints
+    /// with its first color, any other style with the accent color.
+    @_disfavoredOverload
+    public func tint<S: ShapeStyle>(_ tint: S?) -> some View {
+        _styled { $0.extras["tint"] = tint.map { _tintColor(of: $0._json) } ?? .null }
+    }
+
     public func imageScale(_ scale: Image.Scale) -> some View {
         _styled { $0.extras["imageScale"] = .string(scale.name) }
     }
@@ -186,6 +193,11 @@ extension View {
         _styled { $0.extras["badge"] = count == 0 ? .null : .string(String(count)) }
     }
 
+    public func badge(_ key: LocalizedStringKey?) -> some View {
+        _styled { $0.extras["badge"] = key.map { .string($0.key) } ?? .null }
+    }
+
+    @_disfavoredOverload
     public func badge<S: StringProtocol>(_ label: S?) -> some View {
         _styled { $0.extras["badge"] = label.map { .string(String($0)) } ?? .null }
     }
@@ -204,20 +216,41 @@ extension View {
     public func listItemTint(_ tint: Color?) -> some View { self }
     public func formStyle<S: FormStyle>(_ style: S) -> some View { self }
     public func headerProminence(_ prominence: Prominence) -> some View { self }
-    public func containerShape<T: Shape>(_ shape: T) -> some View { self }
+    /// The shape of this container: what a `ContainerRelativeShape`, a
+    /// `.background(_:)` and a `.clipShape(.containerRelative)` below take
+    /// the corners of (its corner radius; a custom shape's are square).
+    public func containerShape<T: Shape>(_ shape: T) -> some View {
+        environment(\._containerShapeRadius, shape._cornerRadius)
+    }
     public func symbolVariant(_ variant: SymbolVariants) -> some View { self }
     public func symbolRenderingMode(_ mode: SymbolRenderingMode?) -> some View { self }
-    public func blendMode(_ mode: BlendMode) -> some View { self }
     public func contentTransition(_ transition: ContentTransition) -> some View { self }
     public func textSelection<S: TextSelectability>(_ selectability: S) -> some View { self }
     public func toolbarRole(_ role: ToolbarRole) -> some View { self }
-    public func controlSize(_ size: ControlSize) -> some View { self }
+    /// The size of the controls inside; a bordered button's height follows it
+    /// (the page: `large` and `extraLarge` are taller).
+    public func controlSize(_ size: ControlSize) -> some View {
+        environment(\.controlSize, size)
+    }
 }
 
 public enum Prominence: Hashable, Sendable { case standard, increased }
 
-/// `.controlSize`: accepted for source compatibility; controls keep one size.
-public enum ControlSize: Hashable, CaseIterable, Sendable { case mini, small, regular, large, extraLarge }
+/// `.controlSize`: bordered buttons take it (props `controlSize` when it is not
+/// `regular`); other controls keep one size.
+public enum ControlSize: Hashable, CaseIterable, Sendable {
+    case mini, small, regular, large, extraLarge
+
+    var _name: String {
+        switch self {
+        case .mini: "mini"
+        case .small: "small"
+        case .regular: "regular"
+        case .large: "large"
+        case .extraLarge: "extraLarge"
+        }
+    }
+}
 
 public struct SymbolVariants: Hashable, Sendable {
     let name: String
@@ -235,6 +268,52 @@ public enum BlendMode: Hashable, Sendable {
     case normal, multiply, screen, overlay, darken, lighten, colorDodge, colorBurn, softLight, hardLight,
          difference, exclusion, hue, saturation, color, luminosity, sourceAtop, destinationOver,
          destinationOut, plusDarker, plusLighter
+
+    /// The CSS `mix-blend-mode` (the Porter-Duff modes and `plusDarker`,
+    /// which CSS has no counterpart for, draw normally).
+    var _css: String {
+        switch self {
+        case .multiply: "multiply"
+        case .screen: "screen"
+        case .overlay: "overlay"
+        case .darken: "darken"
+        case .lighten: "lighten"
+        case .colorDodge: "color-dodge"
+        case .colorBurn: "color-burn"
+        case .softLight: "soft-light"
+        case .hardLight: "hard-light"
+        case .difference: "difference"
+        case .exclusion: "exclusion"
+        case .hue: "hue"
+        case .saturation: "saturation"
+        case .color: "color"
+        case .luminosity: "luminosity"
+        case .plusLighter: "plus-lighter"
+        case .normal, .sourceAtop, .destinationOver, .destinationOut, .plusDarker: "normal"
+        }
+    }
+}
+
+/// How `drawingGroup` renders (accepted for source compatibility).
+public enum ColorRenderingMode: Hashable, Sendable {
+    case nonLinear, linear, extendedLinear
+}
+
+nonisolated extension View {
+    /// Draws the view in front of its siblings with a lower index (CSS
+    /// `z-index`); siblings with the same index draw in order.
+    public func zIndex(_ value: Double) -> some View {
+        _styled { $0.extras["zIndex"] = .number(value) }
+    }
+
+    /// Blends the view with what is behind it (CSS `mix-blend-mode`).
+    public func blendMode(_ mode: BlendMode) -> some View {
+        _styled { $0.extras["blendMode"] = .string(mode._css) }
+    }
+
+    /// Renders the view offscreen before showing it; the browser composites
+    /// it already, so it draws the same.
+    public func drawingGroup(opaque: Bool = false, colorMode: ColorRenderingMode = .nonLinear) -> some View { self }
 }
 
 public struct SafeAreaRegions: OptionSet, Sendable {
@@ -270,21 +349,57 @@ public enum ToolbarRole: Hashable, Sendable { case automatic, navigationStack, b
 /// `.onTapGesture`: a `tapgesture` element whose tap event runs the action.
 struct _TapGestureView<Content: View> {
     let content: Content
-    let action: @MainActor () -> Void
+    let action: @MainActor (CGPoint) -> Void
+    /// The action takes the tap's location: the page sends it (`location`).
+    var wantsLocation = false
+
+    init(content: Content, action: @escaping @MainActor () -> Void) {
+        self.content = content
+        self.action = { _ in action() }
+    }
+
+    init(content: Content, locatedAction: @escaping @MainActor (CGPoint) -> Void) {
+        self.content = content
+        self.action = locatedAction
+        wantsLocation = true
+    }
 }
 extension _TapGestureView: _PrimitiveView {}
 extension _TapGestureView: _HostView {
     var _kind: String { "tapgesture" }
-    func _props(in environment: EnvironmentValues) -> _JSON { .object([:]) }
+    func _props(in environment: EnvironmentValues) -> _JSON {
+        wantsLocation ? .object(["location": .bool(true)]) : .object([:])
+    }
     var _content: [any View] { [content] }
     var _handler: ((_JSON) -> Void)? {
         let action = self.action
-        return { _ in MainActor.assumeIsolated { action() } }
+        return { payload in
+            var point = CGPoint.zero
+            if case .object(let fields) = payload, case .number(let x)? = fields["x"], case .number(let y)? = fields["y"] {
+                point = CGPoint(x: x, y: y)
+            }
+            MainActor.assumeIsolated { action(point) }
+        }
     }
 }
 
-extension View {
+nonisolated extension View {
     public func onTapGesture(count: Int = 1, perform action: @escaping @MainActor () -> Void) -> some View {
         _TapGestureView(content: self, action: action)
     }
 }
+
+/// The color a style tints with: a color as it is, a gradient's first color,
+/// else the accent color.
+func _tintColor(of style: _JSON) -> _JSON {
+    guard case .object(let fields) = style else { return .object(["name": .string("accent")]) }
+    if fields["r"] != nil || fields["name"] != nil || fields["named"] != nil { return style }
+    if let color = fields["colorGradient"] { return color }
+    for key in ["linearGradient", "radialGradient", "angularGradient", "ellipticalGradient"] {
+        if case .object(let gradient)? = fields[key], case .array(let stops)? = gradient["stops"],
+           case .object(let first)? = stops.first, let color = first["color"] {
+            return color
+        }
+    }
+    return .object(["name": .string("accent")])
+}

package/Sources/SwiftUI/API/Entry.swift

@@ -0,0 +1,8 @@
+// `@Entry`: declares an environment value in one line,
+// `extension EnvironmentValues { @Entry var isCompact = false }`. The macro
+// (Sources/SwiftDataMacros/EntryMacro.swift) writes the `EnvironmentKey` and
+// the computed property over it, as Apple's does.
+
+@attached(accessor)
+@attached(peer, names: prefixed(__Key_))
+public macro Entry() = #externalMacro(module: "SwiftDataMacros", type: "EntryMacro")

package/Sources/SwiftUI/API/Environment.swift

@@ -51,6 +51,12 @@ public enum UserInterfaceSizeClass: Hashable, Sendable {
     }
 }
 
+/// The direction of the writing system: views read it to lay out or draw
+/// differently for right-to-left languages.
+public enum LayoutDirection: Hashable, CaseIterable, Sendable {
+    case leftToRight, rightToLeft
+}
+
 /// A key for custom environment values.
 public protocol EnvironmentKey {
     associatedtype Value
@@ -60,24 +66,41 @@ public protocol EnvironmentKey {
 /// Dismisses the current presentation: in a navigation stack, pops the screen.
 public struct DismissAction: Sendable {
     let action: @MainActor () -> Void
-
-    init(_ action: @escaping @MainActor () -> Void) { self.action = action }
+    /// What this action dismisses (a screen of a stack, a sheet), set by the
+    /// runtime, which re-creates the action on every pass: equal identities
+    /// make the environments of two passes the same (see `_Sameness`).
+    let identity: _RuntimeKey?
+
+    init(identity: _RuntimeKey? = nil, _ action: @escaping @MainActor () -> Void) {
+        self.identity = identity
+        self.action = action
+    }
 
     @MainActor public func callAsFunction() { action() }
 }
 
 /// Values propagated down the view tree.
 public struct EnvironmentValues {
-    private var storage: [ObjectIdentifier: Any] = [:]
+    fileprivate var storage: [ObjectIdentifier: Any] = [:]
 
     public init() {}
 
+    /// Whether every stored value is the same as in `other` (`_Sameness`).
+    func _sameStorage(as other: EnvironmentValues) -> Bool {
+        guard storage.count == other.storage.count else { return false }
+        var budget = _Sameness.budget
+        for (key, value) in storage {
+            guard let otherValue = other.storage[key], _Sameness.same(value, otherValue, budget: &budget) else { return false }
+        }
+        return true
+    }
+
     public subscript<K: EnvironmentKey>(key: K.Type) -> K.Value {
         get {
             // An absent entry must fall back to the default even for optional
             // values: `nil as? Optional<V>` would succeed as `.some(nil)`.
-            guard let stored = storage[ObjectIdentifier(key)] else { return K.defaultValue }
-            return stored as? K.Value ?? K.defaultValue
+            guard let stored = storage[ObjectIdentifier(key)] else { return Self._default(of: key) }
+            return stored as? K.Value ?? Self._default(of: key)
         }
         set { storage[ObjectIdentifier(key)] = newValue }
     }
@@ -114,11 +137,41 @@ public struct EnvironmentValues {
         set { self[_VerticalSizeClassKey.self] = newValue }
     }
 
+    /// `.leftToRight`: the renderer lays out left to right, whatever the
+    /// locale. A view may set it (`.environment(\.layoutDirection, …)`) for
+    /// the views it contains, which read it; the layout does not mirror.
+    public var layoutDirection: LayoutDirection {
+        get { self[_LayoutDirectionKey.self] }
+        set { self[_LayoutDirectionKey.self] = newValue }
+    }
+
+    /// The font `.font(_:)` set above this view (a text style or a size;
+    /// `.fontWeight` and `.bold` leave it as is), nil for the default body font.
+    public var font: Font? {
+        get { self[_FontKey.self] }
+        set { self[_FontKey.self] = newValue }
+    }
+
+    /// Pixels per point: 3, the iPhone the page stands for (`UIScreen.main.scale`).
+    public var displayScale: CGFloat {
+        get { self[_DisplayScaleKey.self] }
+        set { self[_DisplayScaleKey.self] = newValue }
+    }
+
+    /// One pixel, in points.
+    public var pixelLength: CGFloat { 1 / displayScale }
+
     var _buttonStyle: String {
         get { self[_ButtonStyleKey.self] }
         set { self[_ButtonStyleKey.self] = newValue }
     }
 
+    /// `.controlSize(_:)`; `regular` by default.
+    public var controlSize: ControlSize {
+        get { self[_ControlSizeKey.self] }
+        set { self[_ControlSizeKey.self] = newValue }
+    }
+
     var _textFieldStyle: String {
         get { self[_TextFieldStyleKey.self] }
         set { self[_TextFieldStyleKey.self] = newValue }
@@ -138,6 +191,15 @@ public struct EnvironmentValues {
     func _anyObject(_ type: Any.Type) -> Any? {
         storage[ObjectIdentifier(type)]
     }
+
+    /// Stores `object` under its dynamic type, for `@Environment(Type.self)` and `@EnvironmentObject`.
+    mutating func _setAnyObject(_ object: AnyObject) {
+        storage[ObjectIdentifier(type(of: object))] = object
+    }
+}
+
+extension EnvironmentValues: CustomStringConvertible {
+    public var description: String { "EnvironmentValues(\(storage.count) values)" }
 }
 
 /// Lets `@Environment(Type.self)` hand back nil for an optional type that was not supplied.
@@ -154,7 +216,11 @@ enum _IsEnabledKey: EnvironmentKey { static let defaultValue = true }
 enum _DynamicTypeSizeKey: EnvironmentKey { static let defaultValue = DynamicTypeSize.large }
 enum _HorizontalSizeClassKey: EnvironmentKey { static let defaultValue: UserInterfaceSizeClass? = .compact }
 enum _VerticalSizeClassKey: EnvironmentKey { static let defaultValue: UserInterfaceSizeClass? = .regular }
+enum _LayoutDirectionKey: EnvironmentKey { static let defaultValue = LayoutDirection.leftToRight }
+enum _FontKey: EnvironmentKey { static let defaultValue: Font? = nil }
+enum _DisplayScaleKey: EnvironmentKey { static let defaultValue: CGFloat = 3 }
 enum _ButtonStyleKey: EnvironmentKey { static let defaultValue = "automatic" }
+enum _ControlSizeKey: EnvironmentKey { static let defaultValue = ControlSize.regular }
 enum _TextFieldStyleKey: EnvironmentKey { static let defaultValue = "plain" }
 
 // MARK: - @Environment
@@ -164,7 +230,17 @@ final class _EnvironmentBox {
 }
 
 /// Views expose their `Environment` properties to the runtime through this protocol.
-protocol _EnvironmentProperty {
+protocol _EnvironmentProperty: _RuntimeProperty {
+    func _resolve(in environment: EnvironmentValues)
+}
+
+/// A property wrapper from another module (SwiftData's `@Query`) that reads
+/// the environment of the view it belongs to: the runtime calls `_resolve`
+/// before each run of the view's body, as for `@Environment`. Unlike
+/// `@Environment`, such a property is part of the view's value when the
+/// runtime decides whether a re-created view is unchanged (Phase 16), so a
+/// parent passing a different query re-runs the view.
+public protocol _EnvironmentReading: _RuntimeProperty {
     func _resolve(in environment: EnvironmentValues)
 }
 
@@ -216,7 +292,7 @@ extension Environment: _EnvironmentProperty {
 
 // MARK: - .environment(_:_:)
 
-protocol _EnvironmentModifying {
+protocol _EnvironmentModifying: _TraitBearing {
     func _apply(to environment: inout EnvironmentValues)
 }
 
@@ -232,7 +308,7 @@ extension _EnvironmentView: _EnvironmentModifying {
     func _apply(to environment: inout EnvironmentValues) { apply(&environment) }
 }
 
-extension View {
+nonisolated extension View {
     public func environment<V>(_ keyPath: WritableKeyPath<EnvironmentValues, V>, _ value: V) -> some View {
         _EnvironmentView(content: self) { $0[keyPath: keyPath] = value }
     }
@@ -268,7 +344,7 @@ extension View {
 }
 
 /// Read by the runtime, which tells the host; also sets the environment's scheme.
-protocol _PreferredColorSchemeModifying {
+protocol _PreferredColorSchemeModifying: _TraitBearing {
     var _preferredColorScheme: ColorScheme? { get }
 }
 
@@ -353,3 +429,18 @@ extension DynamicTypeSize {
         return bodySize / 17
     }
 }
+
+// MARK: - Keys bridged from UIKit traits
+
+/// A key whose value, until a view sets it, comes from elsewhere: UIKit's
+/// `UITraitBridgedEnvironmentKey` (iOS 17) reads it from the current traits.
+public protocol _BridgedEnvironmentKey: EnvironmentKey {
+    static var _bridgedDefault: Any { get }
+}
+
+extension EnvironmentValues {
+    static func _default<K: EnvironmentKey>(of key: K.Type) -> K.Value {
+        if let bridged = key as? any _BridgedEnvironmentKey.Type, let value = bridged._bridgedDefault as? K.Value { return value }
+        return K.defaultValue
+    }
+}

package/Sources/SwiftUI/API/EnvironmentSendable.swift

@@ -0,0 +1,6 @@
+/// `Environment` is `Sendable` when its value is, as in SwiftUI, so a
+/// `Sendable` style or modifier may declare `@Environment` properties
+/// (ButtonKit's shake style reads `accessibilityReduceMotion`). The runtime
+/// resolves the property into its box on the main actor before the body
+/// runs, and only the body reads it.
+extension Environment: @unchecked Sendable where Value: Sendable {}

package/Sources/SwiftUI/API/Focus.swift

@@ -72,7 +72,7 @@ extension EnvironmentValues {
     }
 }
 
-extension View {
+nonisolated extension View {
     /// Binds the field's focus to a `@FocusState var isFocused: Bool`.
     public func focused(_ binding: FocusState<Bool>.Binding) -> some View {
         _EnvironmentView(content: self) {
@@ -80,6 +80,14 @@ extension View {
         }
     }
 
+    /// Binds a field's or text editor's focus to a plain binding: UIKit's
+    /// text views (`becomeFirstResponder`) drawn by a representable.
+    public func _focused(_ isFocused: Binding<Bool>) -> some View {
+        _EnvironmentView(content: self) {
+            $0._focus = _FocusRequest(isFocused: { isFocused.wrappedValue }, setFocused: { isFocused.wrappedValue = $0 })
+        }
+    }
+
     /// Binds the field's focus to one case of a `@FocusState var field: Field?`.
     public func focused<Value: Hashable>(_ binding: FocusState<Value?>.Binding, equals value: Value) -> some View {
         _EnvironmentView(content: self) {
@@ -110,7 +118,7 @@ public enum SubmitLabel: String, Hashable, Sendable {
     case done, go, send, join, route, search, `return`, next, `continue`
 }
 
-extension View {
+nonisolated extension View {
     /// Runs `action` when a text field in this view submits (the Enter key).
     public func onSubmit(of triggers: SubmitTriggers = .text, _ action: @escaping () -> Void) -> some View {
         _EnvironmentView(content: self) { $0._onSubmit = action }
@@ -124,6 +132,6 @@ extension View {
 /// A host view whose event handler needs the environment (the focus and
 /// submit closures a text field inherits); checked by the runtime ahead of
 /// `_HostView._handler`.
-protocol _EnvironmentHandling {
+protocol _EnvironmentHandling: _TraitBearing {
     func _handler(in environment: EnvironmentValues) -> ((_JSON) -> Void)?
 }