@swiftbrowser/swift 0.3.1 → 0.5.0

package/Sources/FoundationBridge/ItemProvider.swift

@@ -7,11 +7,13 @@
 // file representation is a copy in the temporary directory, removed once the
 // handler returns, as on iOS.
 //
-// SwiftUI's drag-and-drop API takes providers, so it lives here (the SwiftUI
-// shim cannot see this module): `onDrop`, `onDrag`, `DropInfo`,
-// `DropDelegate`. The page has no drag and drop between views or apps yet,
-// so the views are left as they are and nothing is ever dropped
-// (docs/ops-protocol.md, "Sharing and media").
+// SwiftUI's provider-based drag-and-drop API lives here (the SwiftUI shim
+// cannot see this module): `onDrop`, `onDrag`, `DropInfo`, `DropDelegate`,
+// over the shim's `draggable` / `dropdestination` elements. A drag's
+// provider is made when it begins; a drop hands the destination the
+// source's provider (a `Transferable` payload becomes one) and one provider
+// per item dragged in from outside the page (docs/ops-protocol.md, "Drag
+// and drop").
 
 import Foundation
 import SwiftUI
@@ -572,7 +574,6 @@ struct _UnsafeBox<Value>: @unchecked Sendable {
 // MARK: - SwiftUI: drag and drop
 
 /// What a drop offers: where it is and the providers of what was dropped.
-/// The page has no drag and drop yet, so no drop is ever delivered.
 public struct DropInfo {
     public let location: SwiftUI.CGPoint
     let providers: [NSItemProvider]
@@ -610,7 +611,7 @@ public struct DropProposal: Sendable {
 }
 
 /// What a drop target is told as a drag moves over it and drops. Every
-/// method has a default, as on iOS. Never called in the browser yet.
+/// method has a default, as on iOS.
 @MainActor
 public protocol DropDelegate {
     func validateDrop(info: DropInfo) -> Bool
@@ -627,28 +628,97 @@ extension DropDelegate {
     public func dropExited(info: DropInfo) {}
 }
 
+extension Transferable {
+    /// A provider of `self` in every type it exports.
+    fileprivate func _itemProvider() -> NSItemProvider {
+        let provider = NSItemProvider()
+        let boxed = _UnsafeBox(self)
+        provider.register(boxed.value)
+        return provider
+    }
+}
+
+extension DropInfo {
+    /// What a drop offers as providers: the dragged view's provider (its
+    /// `onDrag` provider as it is, a `draggable` payload registered in the
+    /// types it exports) and one per item from outside the page.
+    init(_ items: _DropItems) {
+        var providers: [NSItemProvider] = []
+        if let provider = items.source as? NSItemProvider {
+            providers.append(provider)
+        } else if let transferable = items.source as? any Transferable {
+            providers.append(transferable._itemProvider())
+        }
+        for content in items.contents {
+            let provider = NSItemProvider()
+            let data = content.data ?? Data()
+            provider.registerDataRepresentation(for: content.contentType) { completion in
+                completion(data, nil)
+                return nil
+            }
+            provider.suggestedName = content.suggestedName
+            providers.append(provider)
+        }
+        self.init(_location: items.location, providers: providers)
+    }
+}
+
 extension View {
-    /// Accepted; nothing is dropped in the browser, so `action` is never called.
+    /// The view takes drops that carry one of `supportedContentTypes`: a
+    /// dragged view's provider, or text, links and files dragged in from
+    /// outside the page. `isTargeted` is set while a drag is over the view;
+    /// `action` gets the providers and says whether it took them.
     public func onDrop(of supportedContentTypes: [UTType], isTargeted: Binding<Bool>?,
-                       perform action: @escaping ([NSItemProvider]) -> Bool) -> some View { self }
+                       perform action: @escaping ([NSItemProvider]) -> Bool) -> some View {
+        onDrop(of: supportedContentTypes, isTargeted: isTargeted) { providers, _ in action(providers) }
+    }
 
-    /// Accepted; nothing is dropped in the browser, so `action` is never called.
+    /// As above, with the drop's point in the view's coordinates.
     public func onDrop(of supportedContentTypes: [UTType], isTargeted: Binding<Bool>?,
-                       perform action: @escaping ([NSItemProvider], SwiftUI.CGPoint) -> Bool) -> some View { self }
+                       perform action: @escaping ([NSItemProvider], SwiftUI.CGPoint) -> Bool) -> some View {
+        _DropDestinationView(content: self, accepts: _dropAccepts(supportedContentTypes),
+                             targeted: { targeted, _ in isTargeted?.wrappedValue = targeted }) { items in
+            let info = DropInfo(items)
+            let providers = info.itemProviders(for: supportedContentTypes)
+            guard !providers.isEmpty else { return false }
+            return action(providers, items.location)
+        }
+    }
 
-    /// Accepted; nothing is dropped in the browser, so the delegate hears nothing.
-    public func onDrop(of supportedContentTypes: [UTType], delegate: any DropDelegate) -> some View { self }
+    /// The delegate hears the drag enter and leave (`dropEntered`,
+    /// `dropExited`, with what it carries) and takes the drop
+    /// (`validateDrop`, then `performDrop`).
+    public func onDrop(of supportedContentTypes: [UTType], delegate: any DropDelegate) -> some View {
+        _DropDestinationView(content: self, accepts: _dropAccepts(supportedContentTypes),
+                             targeted: { targeted, items in
+                                 if targeted { delegate.dropEntered(info: DropInfo(items)) } else { delegate.dropExited(info: DropInfo(items)) }
+                             }) { items in
+            let info = DropInfo(items)
+            guard info.hasItemsConforming(to: supportedContentTypes), delegate.validateDrop(info: info) else { return false }
+            return delegate.performDrop(info: info)
+        }
+    }
 
     public func onDrop(of supportedTypes: [String], isTargeted: Binding<Bool>?,
-                       perform action: @escaping ([NSItemProvider]) -> Bool) -> some View { self }
+                       perform action: @escaping ([NSItemProvider]) -> Bool) -> some View {
+        onDrop(of: supportedTypes.map(NSItemProvider.type), isTargeted: isTargeted, perform: action)
+    }
 
-    public func onDrop(of supportedTypes: [String], delegate: any DropDelegate) -> some View { self }
+    public func onDrop(of supportedTypes: [String], delegate: any DropDelegate) -> some View {
+        onDrop(of: supportedTypes.map(NSItemProvider.type), delegate: delegate)
+    }
 
-    /// Accepted; the view cannot be dragged in the browser.
-    public func onDrag(_ data: @escaping () -> NSItemProvider) -> some View { self }
+    /// The view can be dragged: a long press lifts it on a touch screen, a
+    /// drag does with a mouse. `data` runs when the drag begins; its provider
+    /// reaches the `onDrop` (or `dropDestination`) the view is dropped on.
+    public func onDrag(_ data: @escaping () -> NSItemProvider) -> some View {
+        _DraggableView(content: self) { data() }
+    }
 
-    /// Accepted; the view cannot be dragged in the browser.
-    public func onDrag<Preview: View>(_ data: @escaping () -> NSItemProvider, @ViewBuilder preview: () -> Preview) -> some View { self }
+    /// The page drags a copy of the view itself; `preview` is accepted and not drawn.
+    public func onDrag<Preview: View>(_ data: @escaping () -> NSItemProvider, @ViewBuilder preview: () -> Preview) -> some View {
+        _DraggableView(content: self) { data() }
+    }
 
     /// Accepted (macOS's services and iOS's drag source): nothing asks for the provider.
     public func itemProvider(_ action: (() -> NSItemProvider?)?) -> some View { self }

package/Sources/SwiftUI/API/EditMode.swift

@@ -42,11 +42,14 @@ public protocol DynamicViewContent: View {
 
 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`.
+/// A keyed group whose rows a `List` can delete or move. The runtime wraps
+/// each row in a `listrow` with `deletable` / `movable` (docs/ops-protocol.md,
+/// "Reordering rows").
 protocol _DeletableGroup: _TraitBearing {
     /// Calls the group's `onDelete` with the row at `offset`; nil without one.
     var _delete: ((Int) -> Void)? { get }
+    /// Calls the group's `onMove` with the row at the first offset and the
+    /// destination offset (both in the group's data); nil without one.
     var _move: ((Int, Int) -> Void)? { get }
 }
 
@@ -76,7 +79,10 @@ extension DynamicViewContent {
         _EditableForEach(base: self, delete: action.map { action in { action(IndexSet(integer: $0)) } }, move: nil)
     }
 
-    /// Accepted for source compatibility; the renderer offers no reordering yet.
+    /// Lets a `List` reorder the rows: in edit mode each row gains a grip at
+    /// its trailing edge, and outside it a long press lifts the row; `action`
+    /// receives the moved row's offset and the destination offset in `data`,
+    /// as `move(fromOffsets:toOffset:)` takes them. Pass `nil` to opt out.
     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) } })
     }
@@ -96,27 +102,33 @@ extension _EditableForEach {
 /// `.deleteDisabled` / `.moveDisabled` on a row.
 protocol _RowEditingDisabling: _TraitBearing {
     var _deleteDisabled: Bool { get }
+    var _moveDisabled: Bool { get }
 }
 
-struct _DeleteDisabledView<Content: View> {
+struct _RowEditingDisabledView<Content: View> {
     let content: Content
-    let disabled: Bool
+    var deleteDisabled = false
+    var moveDisabled = false
 }
-extension _DeleteDisabledView: _PrimitiveView {}
-extension _DeleteDisabledView: _GroupView {
+extension _RowEditingDisabledView: _PrimitiveView {}
+extension _RowEditingDisabledView: _GroupView {
     var _children: [any View] { [content] }
 }
-extension _DeleteDisabledView: _RowEditingDisabling {
-    var _deleteDisabled: Bool { disabled }
+extension _RowEditingDisabledView: _RowEditingDisabling {
+    var _deleteDisabled: Bool { deleteDisabled }
+    var _moveDisabled: Bool { moveDisabled }
 }
 
 nonisolated extension View {
     public func deleteDisabled(_ isDisabled: Bool) -> some View {
-        _DeleteDisabledView(content: self, disabled: isDisabled)
+        _RowEditingDisabledView(content: self, deleteDisabled: isDisabled)
     }
 
-    /// Accepted for source compatibility; rows cannot be moved yet.
-    public func moveDisabled(_ isDisabled: Bool) -> some View { self }
+    /// The row keeps its place: no grip in edit mode, and a long press does
+    /// not lift it.
+    public func moveDisabled(_ isDisabled: Bool) -> some View {
+        _RowEditingDisabledView(content: self, moveDisabled: isDisabled)
+    }
 }
 
 // MARK: - Edit mode

package/Sources/SwiftUI/API/Inspector.swift

@@ -0,0 +1,64 @@
+// `.inspector(isPresented:content:)`: a trailing panel beside the content in
+// the regular size class (an `inspector` element whose last child is the
+// `inspectorpanel`), a sheet in the compact one, as on iPadOS / iOS. See
+// docs/ops-protocol.md, "Inspector".
+
+extension View {
+    /// Shows `content` in a trailing column beside this view while
+    /// `isPresented` is true (regular width), or in a sheet (compact width).
+    public func inspector<Content: View>(isPresented: Binding<Bool>,
+                                         @ViewBuilder content: () -> Content) -> some View {
+        _InspectorView(base: self, isPresented: isPresented, inspector: content())
+    }
+}
+
+nonisolated extension View {
+    /// The inspector column's width (on the inspector's content).
+    public func inspectorColumnWidth(_ width: CGFloat) -> some View {
+        _styled { $0.extras["inspectorColumnWidth"] = .number(width) }
+    }
+
+    /// The inspector column's width: the ideal one (the column does not resize).
+    public func inspectorColumnWidth(min: CGFloat? = nil, ideal: CGFloat, max: CGFloat? = nil) -> some View {
+        inspectorColumnWidth(ideal)
+    }
+}
+
+struct _InspectorView<Base: View, Inspector: View>: View {
+    let base: Base
+    let isPresented: Binding<Bool>
+    let inspector: Inspector
+    @Environment(\.horizontalSizeClass) private var sizeClass
+
+    var body: some View {
+        if sizeClass == .regular {
+            _InspectorColumns(main: base, panel: _InspectorPanel(content: inspector), presented: isPresented.wrappedValue)
+        } else {
+            base.sheet(isPresented: isPresented) { inspector }
+        }
+    }
+}
+
+/// The content and, last, the panel; `presented` slides the panel in.
+struct _InspectorColumns<Main: View, Panel: View> {
+    let main: Main
+    let panel: Panel
+    let presented: Bool
+}
+extension _InspectorColumns: _PrimitiveView {}
+extension _InspectorColumns: _HostView {
+    var _kind: String { "inspector" }
+    func _props(in environment: EnvironmentValues) -> _JSON { .object(["presented": .bool(presented)]) }
+    var _content: [any View] { [main, panel] }
+}
+
+/// The inspector column's content.
+struct _InspectorPanel<Content: View> {
+    let content: Content
+}
+extension _InspectorPanel: _PrimitiveView {}
+extension _InspectorPanel: _HostView {
+    var _kind: String { "inspectorpanel" }
+    func _props(in environment: EnvironmentValues) -> _JSON { .object([:]) }
+    var _content: [any View] { [content] }
+}

package/Sources/SwiftUI/API/Lists.swift

@@ -3,9 +3,16 @@
 public protocol ListStyle {
     var _name: String { get }
 }
+/// `.automatic`: inset grouped, or `sidebar` in a `NavigationSplitView`'s
+/// sidebar in the regular size class (resolved in `List._props`).
 public struct DefaultListStyle: ListStyle {
     public init() {}
-    public var _name: String { "insetGrouped" }
+    public var _name: String { "automatic" }
+}
+/// iPadOS's sidebar list: rows on the background, no cards or hairlines.
+public struct SidebarListStyle: ListStyle {
+    public init() {}
+    public var _name: String { "sidebar" }
 }
 public struct PlainListStyle: ListStyle {
     public init() {}
@@ -31,6 +38,9 @@ extension ListStyle where Self == InsetGroupedListStyle {
 extension ListStyle where Self == GroupedListStyle {
     public static var grouped: GroupedListStyle { GroupedListStyle() }
 }
+extension ListStyle where Self == SidebarListStyle {
+    public static var sidebar: SidebarListStyle { SidebarListStyle() }
+}
 
 nonisolated extension View {
     public func listStyle<S: ListStyle>(_ style: S) -> some View {
@@ -203,11 +213,13 @@ extension List: _HostView {
     /// `editing` (the environment's edit mode) and `refreshable` / `refreshing`
     /// (`.refreshable`) are present only when true / when refreshable.
     func _props(in environment: EnvironmentValues) -> _JSON {
-        var props: [String: _JSON] = ["style": .string(environment._listStyle)]
+        var props: [String: _JSON] = ["style": .string(Self._resolvedStyle(in: environment))]
         if environment.editMode?.wrappedValue.isEditing == true { props["editing"] = .bool(true) }
         _refresh(in: environment).addProps(to: &props)
         // `.scrollDismissesKeyboard` (ScrollModifiers.swift).
         if environment._scrollDismissesKeyboard { props["dismissesKeyboard"] = .bool(true) }
+        // `.scrollEdgeEffectStyle` / `.scrollEdgeEffectHidden` (ScrollModifiers.swift).
+        if let edges = environment._scrollEdgeEffects.props { props["edgeEffect"] = edges }
         // `.scrollContentBackground(.hidden)` (ScrollViewReader.swift).
         if environment._scrollContentBackground == .hidden { props["background"] = .string("hidden") }
         // `.environment(\.defaultMinListRowHeight, 1)`: rows as short as their content.
@@ -217,6 +229,14 @@ extension List: _HostView {
     var _content: [any View] { [content] }
     var _handler: ((_JSON) -> Void)? { nil }
 
+    /// `.automatic` is `sidebar` in a split view's sidebar on a regular-width
+    /// screen (as SwiftUI does), else inset grouped.
+    static func _resolvedStyle(in environment: EnvironmentValues) -> String {
+        let style = environment._listStyle
+        guard style == "automatic" else { return style }
+        return environment._splitSidebar && environment.horizontalSizeClass == .regular ? "sidebar" : "insetGrouped"
+    }
+
     func _refresh(in environment: EnvironmentValues) -> _Refresh {
         _Refresh(action: environment._refreshAction, refreshing: $refreshing)
     }

package/Sources/SwiftUI/API/Navigation.swift

@@ -226,10 +226,13 @@ extension NavigationLink: _NavigationLinkView {
 
 // MARK: - NavigationSplitView
 
-/// Which columns of a `NavigationSplitView` are shown. Accepted for source
-/// compatibility; the shim shows the sidebar and the detail (see below).
+/// Which columns of a `NavigationSplitView` are shown: `detailOnly` hides
+/// the sidebar; every other value shows it beside the detail (the optional
+/// middle column is part of the detail, see below).
 public struct NavigationSplitViewVisibility: Hashable, Sendable {
     let name: String
+    /// Whether the sidebar column is shown.
+    var _showsSidebar: Bool { name != "detailOnly" }
     public static let automatic = NavigationSplitViewVisibility(name: "automatic")
     public static let all = NavigationSplitViewVisibility(name: "all")
     public static let doubleColumn = NavigationSplitViewVisibility(name: "doubleColumn")
@@ -266,6 +269,9 @@ protocol _NavigationSplitHost: _TraitBearing {
     var _detail: any View { get }
     /// Screens pushed from the compact detail (links inside it).
     var _pushedBox: _StateBox<[_PushedScreen]> { get }
+    /// The columns shown in the regular size class: the `columnVisibility`
+    /// binding, else the split view's own state. The sidebar toggle sets it.
+    var _columnVisibility: Binding<NavigationSplitViewVisibility> { get }
 }
 
 /// A two-column navigation interface: a sidebar whose list selection drives
@@ -274,11 +280,14 @@ protocol _NavigationSplitHost: _TraitBearing {
 public struct NavigationSplitView<Sidebar: View, Content: View, Detail: View> {
     let sidebar: Sidebar
     let detail: Detail
+    let columnVisibility: Binding<NavigationSplitViewVisibility>?
     @State var pushed: [_PushedScreen] = []
+    @State var visibility: NavigationSplitViewVisibility = .automatic
 
     public init(@ViewBuilder sidebar: () -> Sidebar, @ViewBuilder detail: () -> Detail) where Content == EmptyView {
         self.sidebar = sidebar()
         self.detail = detail()
+        columnVisibility = nil
     }
 
     public init(@ViewBuilder sidebar: () -> Sidebar, @ViewBuilder content: () -> Content,
@@ -286,13 +295,16 @@ public struct NavigationSplitView<Sidebar: View, Content: View, Detail: View> {
         self.sidebar = sidebar()
         _ = content()
         self.detail = detail()
+        columnVisibility = nil
     }
 
-    /// The visibility binding is accepted and ignored.
+    /// `columnVisibility` shows or hides the sidebar (`detailOnly` hides it),
+    /// and the sidebar toggle sets it.
     public init(columnVisibility: Binding<NavigationSplitViewVisibility>,
                 @ViewBuilder sidebar: () -> Sidebar, @ViewBuilder detail: () -> Detail) where Content == EmptyView {
         self.sidebar = sidebar()
         self.detail = detail()
+        self.columnVisibility = columnVisibility
     }
 
     public init(columnVisibility: Binding<NavigationSplitViewVisibility>,
@@ -301,6 +313,7 @@ public struct NavigationSplitView<Sidebar: View, Content: View, Detail: View> {
         self.sidebar = sidebar()
         _ = content()
         self.detail = detail()
+        self.columnVisibility = columnVisibility
     }
 }
 extension NavigationSplitView: _PrimitiveView {}
@@ -313,6 +326,7 @@ extension NavigationSplitView: _NavigationSplitHost {
     var _sidebar: any View { sidebar }
     var _detail: any View { detail }
     var _pushedBox: _StateBox<[_PushedScreen]> { _pushed.box }
+    var _columnVisibility: Binding<NavigationSplitViewVisibility> { columnVisibility ?? $visibility }
 }
 
 /// Marks the sidebar subtree of a split view: value links there select

package/Sources/SwiftUI/API/Picker.swift

@@ -46,7 +46,7 @@ nonisolated extension View {
 }
 
 enum _PickerStyleKey: EnvironmentKey { static let defaultValue = "menu" }
-enum _ListStyleKey: EnvironmentKey { static let defaultValue = "insetGrouped" }
+enum _ListStyleKey: EnvironmentKey { static let defaultValue = "automatic" }
 
 extension EnvironmentValues {
     var _pickerStyle: String {

package/Sources/SwiftUI/API/Primitives.swift

@@ -363,6 +363,8 @@ extension ScrollView: _HostView {
         if let snap = environment._scrollTargetBehavior { props["snap"] = .string(snap) }
         // `.scrollDismissesKeyboard` (ScrollModifiers.swift).
         if environment._scrollDismissesKeyboard { props["dismissesKeyboard"] = .bool(true) }
+        // `.scrollEdgeEffectStyle` / `.scrollEdgeEffectHidden` (ScrollModifiers.swift).
+        if let edges = environment._scrollEdgeEffects.props { props["edgeEffect"] = edges }
         return .object(props)
     }
     var _content: [any View] { [content] }

package/Sources/SwiftUI/API/ScrollModifiers.swift

@@ -7,8 +7,14 @@
 //   no keyboard to drag down). `.automatic` and `.never` add nothing.
 // - `.scrollIndicators(_:axes:)`: accepted; the page's scroll views never
 //   show scroll bars (iOS shows them only while scrolling).
-// - `.scrollEdgeEffectStyle(_:for:)` (iOS 26): accepted; the page draws no
-//   edge blur under the bars.
+// - `.scrollEdgeEffectStyle(_:for:)` and `.scrollEdgeEffectHidden(_:for:)`
+//   (iOS 26): the lists and scroll views below carry `"edgeEffect": {"top":
+//   …, "bottom": …}`, each `"hard"`, `"soft"` or `"hidden"` (absent:
+//   automatic, the soft effect). The page draws the effect where a scroll
+//   view runs under its screen's bar or a bar covering the bottom (styles.css):
+//   soft blurs and fades the content there, hard puts an opaque backing with a
+//   dividing line behind the bar. The closest modifier wins per edge; hidden
+//   wins over a style; leading and trailing are accepted and ignored.
 // - `.safeAreaInset(edge:alignment:spacing:content:)`: approximated as a
 //   stack: the inset view takes its room above or below (before or after)
 //   the view, which gets the rest, instead of overlapping a scroll view's
@@ -39,12 +45,38 @@ public struct ScrollEdgeEffectStyle: Hashable, Sendable {
 
 enum _ScrollDismissesKeyboardKey: EnvironmentKey { static let defaultValue = false }
 
+/// `.scrollEdgeEffectStyle` / `.scrollEdgeEffectHidden` above a scroll view,
+/// for its top and bottom edges.
+struct _ScrollEdgeEffects: Hashable, Sendable {
+    /// `"hard"` or `"soft"`; nil is automatic.
+    var topStyle: String?
+    var bottomStyle: String?
+    var topHidden = false
+    var bottomHidden = false
+
+    /// The `edgeEffect` prop of a list or scroll view, nil when both edges are automatic.
+    var props: _JSON? {
+        var edges: [String: _JSON] = [:]
+        if let top = topHidden ? "hidden" : topStyle { edges["top"] = .string(top) }
+        if let bottom = bottomHidden ? "hidden" : bottomStyle { edges["bottom"] = .string(bottom) }
+        return edges.isEmpty ? nil : .object(edges)
+    }
+}
+
+enum _ScrollEdgeEffectsKey: EnvironmentKey { static let defaultValue = _ScrollEdgeEffects() }
+
 extension EnvironmentValues {
     /// `.scrollDismissesKeyboard(.immediately | .interactively)` above a list or scroll view.
     var _scrollDismissesKeyboard: Bool {
         get { self[_ScrollDismissesKeyboardKey.self] }
         set { self[_ScrollDismissesKeyboardKey.self] = newValue }
     }
+
+    /// `.scrollEdgeEffectStyle` / `.scrollEdgeEffectHidden` above a list or scroll view.
+    var _scrollEdgeEffects: _ScrollEdgeEffects {
+        get { self[_ScrollEdgeEffectsKey.self] }
+        set { self[_ScrollEdgeEffectsKey.self] = newValue }
+    }
 }
 
 nonisolated extension View {
@@ -56,9 +88,23 @@ nonisolated extension View {
         self
     }
 
-    public func scrollEdgeEffectStyle(_ style: ScrollEdgeEffectStyle?, for edges: Edge.Set) -> some View { self }
+    /// The scroll edge effect of the scroll views below on `edges` (top and
+    /// bottom): `.hard`, `.soft`, or `.automatic` / nil (soft on iOS).
+    public func scrollEdgeEffectStyle(_ style: ScrollEdgeEffectStyle?, for edges: Edge.Set) -> some View {
+        transformEnvironment(\._scrollEdgeEffects) { effects in
+            let name = style.flatMap { $0 == .automatic ? nil : $0.name }
+            if edges.contains(.top) { effects.topStyle = name }
+            if edges.contains(.bottom) { effects.bottomStyle = name }
+        }
+    }
 
-    public func scrollEdgeEffectHidden(_ hidden: Bool = true, for edges: Edge.Set = .all) -> some View { self }
+    /// Hides (or shows again) the scroll edge effect of the scroll views below on `edges`.
+    public func scrollEdgeEffectHidden(_ hidden: Bool = true, for edges: Edge.Set = .all) -> some View {
+        transformEnvironment(\._scrollEdgeEffects) { effects in
+            if edges.contains(.top) { effects.topHidden = hidden }
+            if edges.contains(.bottom) { effects.bottomHidden = hidden }
+        }
+    }
 
     public func safeAreaInset<V: View>(edge: VerticalEdge, alignment: HorizontalAlignment = .center,
                                        spacing: CGFloat? = nil, @ViewBuilder content: () -> V) -> some View {

package/Sources/SwiftUI/API/StatusGaps.swift

@@ -26,11 +26,22 @@ extension AnyTransition {
 }
 
 /// Space between toolbar items (iOS 26), which separates Liquid Glass
-/// groups. The page lays a placement's items out in a row of its own, so the
-/// spacer adds nothing.
+/// groups: an empty `toolbar` element of its placement with `"spacer":
+/// "flexible"` or `"fixed"`. In a bottom bar flexible spacers share the room
+/// left over and push the groups apart (Toolbar.swift); in the navigation
+/// bar they only separate groups.
 nonisolated public struct ToolbarSpacer: ToolbarContent {
-    public init(_ sizing: SpacerSizing = .flexible, placement: ToolbarItemPlacement = .automatic) {}
-    nonisolated public var _toolbarItems: [any View] { [] }
+    let sizing: SpacerSizing
+    let placement: ToolbarItemPlacement
+
+    public init(_ sizing: SpacerSizing = .flexible, placement: ToolbarItemPlacement = .automatic) {
+        self.sizing = sizing
+        self.placement = placement
+    }
+
+    nonisolated public var _toolbarItems: [any View] {
+        [_ToolbarGroupView(placement: placement, items: [], spacer: sizing.name)]
+    }
 }
 
 /// How much room a `ToolbarSpacer` takes.

package/Sources/SwiftUI/API/Toolbar.swift

@@ -33,15 +33,21 @@ public protocol ToolbarContent {
     nonisolated var _toolbarItems: [any View] { get }
 }
 
-/// A `toolbar` element: the items of one placement.
+/// A `toolbar` element: the items of one placement, or a `ToolbarSpacer`
+/// (`spacer`: `"flexible"` or `"fixed"`, no items).
 struct _ToolbarGroupView {
     let placement: ToolbarItemPlacement
     let items: [any View]
+    var spacer: String? = nil
 }
 extension _ToolbarGroupView: _PrimitiveView {}
 extension _ToolbarGroupView: _HostView {
     var _kind: String { "toolbar" }
-    func _props(in environment: EnvironmentValues) -> _JSON { .object(["placement": .string(placement.name)]) }
+    func _props(in environment: EnvironmentValues) -> _JSON {
+        var props: [String: _JSON] = ["placement": .string(placement.name)]
+        if let spacer { props["spacer"] = .string(spacer) }
+        return .object(props)
+    }
     var _content: [any View] { items }
 }
 extension _ToolbarGroupView: _EnvironmentModifying {

package/Sources/SwiftUI/API/Transfer.swift

@@ -4,9 +4,9 @@ import Foundation
 @_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").
+// `ShareLink`'s export of other items (docs/ops-protocol.md, "Sharing and
+// media"), the drag-and-drop modifiers ("Drag and drop") and the clipboard
+// modifiers that take `Transferable` payloads.
 
 // MARK: - Image
 
@@ -112,26 +112,234 @@ enum _ShareExport {
     }
 }
 
-// MARK: - Drag and drop, copy and paste
+// MARK: - Drag and drop
 
-// 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.
+// A `draggable` element wraps a view the page can lift (a long press on a
+// touch screen, a drag with a mouse) and carry over the screen; a
+// `dropdestination` element hears `drop` events with the phase `entered`,
+// `exited` or `performed`. What travels stays in Swift: the source's payload
+// is kept by `_DragSession` while the drag lasts (from `dragstart` to
+// `dragend`), and a drop names the source element. Text, links and files
+// dragged in from outside the page arrive as `items`, which become
+// `_TransferContent`s the destination's type imports
+// (docs/ops-protocol.md, "Drag and drop").
+
+/// The drag in progress: the `draggable` element it started on and the
+/// payload its closure made when it began. Nil between drags.
+@MainActor
+public enum _DragSession {
+    public static var current: (source: Int, payload: Any)?
+}
+
+/// `.draggable(_:)` / `onDrag`: the content under a `draggable` element.
+/// `payload` runs when the drag begins, as `onDrag`'s provider closure does.
+public struct _DraggableView<Content: View> {
+    let content: Content
+    let payload: @MainActor () -> Any
+
+    public init(content: Content, payload: @escaping @MainActor () -> Any) {
+        self.content = content
+        self.payload = payload
+    }
+}
+extension _DraggableView: _PrimitiveView {}
+extension _DraggableView: _HostView {
+    var _kind: String { "draggable" }
+    func _props(in environment: EnvironmentValues) -> _JSON { .object([:]) }
+    var _content: [any View] { [content] }
+    var _handler: ((_JSON) -> Void)? {
+        let payload = self.payload
+        return { event in
+            guard case .object(let fields) = event, case .string(let type)? = fields["type"],
+                  case .number(let id)? = fields["id"] else { return }
+            MainActor.assumeIsolated {
+                switch type {
+                case "dragstart":
+                    _DragSession.current = (source: Int(id), payload: payload())
+                case "dragend":
+                    if _DragSession.current?.source == Int(id) { _DragSession.current = nil }
+                default:
+                    break
+                }
+            }
+        }
+    }
+}
+
+/// What a drop (or a drag passing over a destination) offers.
+public struct _DropItems {
+    /// Where in the destination's own coordinates (zero while entering and leaving).
+    public let location: CGPoint
+    /// The payload of the `draggable` / `onDrag` source the drag started on,
+    /// when it started in the app; nil for a drag from outside the page.
+    public let source: Any?
+    /// What came from outside the page: text as UTF-8 plain text, a link as
+    /// `public.url`, a file in its type, named after the file.
+    public let contents: [_TransferContent]
+
+    public init(location: CGPoint, source: Any?, contents: [_TransferContent]) {
+        self.location = location
+        self.source = source
+        self.contents = contents
+    }
+
+    /// The source payload as `T`, else the source exported into a type `T`
+    /// imports, then every outside content `T` imports; in that order.
+    @MainActor
+    public func values<T: Transferable>(of type: T.Type) async -> [T] {
+        var values: [T] = []
+        if let source {
+            if let value = source as? T {
+                values.append(value)
+            } else if let item = source as? any Transferable,
+                      let content = try? await item._export(as: _Transfer.importedContentTypes(T.self)),
+                      let value = try? await _Transfer.import(T.self, from: content) {
+                values.append(value)
+            }
+        }
+        for content in contents {
+            if let value = try? await _Transfer.import(T.self, from: content) { values.append(value) }
+        }
+        return values
+    }
+
+    /// The `items` of a `drop` event as transfer contents: `{type, text}`
+    /// for text and links, `{type, name, data}` (base64) for files.
+    static func contents(of items: _JSON?) -> [_TransferContent] {
+        guard case .array(let list)? = items else { return [] }
+        return list.compactMap { item -> _TransferContent? in
+            guard case .object(let fields) = item else { return nil }
+            let mime: String = if case .string(let type)? = fields["type"] { type } else { "" }
+            if case .string(let text)? = fields["text"] {
+                let isLink = mime == "text/uri-list"
+                return _TransferContent(contentType: isLink ? .url : .utf8PlainText, data: Data(text.utf8))
+            }
+            guard case .string(let encoded)? = fields["data"], let data = Data(base64Encoded: encoded) else { return nil }
+            let name: String? = if case .string(let name)? = fields["name"] { name } else { nil }
+            let type = UTType(mimeType: mime) ?? name.flatMap { UTType(filenameExtension: ($0 as NSString).pathExtension) } ?? .data
+            return _TransferContent(contentType: type, data: data, suggestedName: name.map { ($0 as NSString).deletingPathExtension })
+        }
+    }
+}
+
+extension Transferable {
+    /// `self` exported in the first of `types` it exports; nil if none.
+    nonisolated(nonsending) func _export(as types: [UTType]) async throws -> _TransferContent? {
+        for type in types {
+            if let content = try await _Transfer.export(self, as: type) { return content }
+        }
+        return nil
+    }
+}
+
+/// The MIME patterns (`text/plain`, `image/*`, `*/*`) of what dragged in from
+/// outside the page a destination accepting `types` takes: the page matches
+/// them against the drag's types. A type's own MIME type (`application/json`)
+/// when it declares one; any text for a text type, any image for `image`,
+/// anything for `data`, `item`, `content` and files. An app's own type that
+/// no file or text carries matches nothing.
+public func _dropAccepts(_ types: [UTType]) -> [String] {
+    var out: [String] = []
+    for type in types {
+        let pattern: String? =
+            if type == .data || type == .item || type == .content || type == .fileURL { "*/*" }
+            else if let mime = type.preferredMIMEType { mime }
+            else if type.conforms(to: .text) { "text/plain" }
+            else if type.conforms(to: .url) { "text/uri-list" }
+            else if type.conforms(to: .image) { "image/*" }
+            else { nil }
+        if let pattern, !out.contains(pattern) { out.append(pattern) }
+    }
+    return out
+}
+
+/// `.dropDestination` / `onDrop`: the content under a `dropdestination`
+/// element. `targeted` is told when a drag enters and leaves, `perform` when
+/// one drops; both receive what is offered.
+public struct _DropDestinationView<Content: View> {
+    let content: Content
+    let accepts: [String]
+    let targeted: @MainActor (Bool, _DropItems) -> Void
+    let perform: @MainActor (_DropItems) -> Bool
+
+    public init(content: Content, accepts: [String],
+                targeted: @escaping @MainActor (Bool, _DropItems) -> Void,
+                perform: @escaping @MainActor (_DropItems) -> Bool) {
+        self.content = content
+        self.accepts = accepts
+        self.targeted = targeted
+        self.perform = perform
+    }
+}
+extension _DropDestinationView: _PrimitiveView {}
+extension _DropDestinationView: _HostView {
+    var _kind: String { "dropdestination" }
+    func _props(in environment: EnvironmentValues) -> _JSON {
+        .object(["accepts": .array(accepts.map { .string($0) })])
+    }
+    var _content: [any View] { [content] }
+    var _handler: ((_JSON) -> Void)? {
+        let targeted = self.targeted
+        let perform = self.perform
+        return { event in
+            guard case .object(let fields) = event, case .string("drop")? = fields["type"],
+                  case .string(let phase)? = fields["phase"] else { return }
+            var location = CGPoint.zero
+            if case .number(let x)? = fields["x"], case .number(let y)? = fields["y"] { location = CGPoint(x: x, y: y) }
+            MainActor.assumeIsolated {
+                var source: Any?
+                if case .number(let id)? = fields["source"], let current = _DragSession.current, current.source == Int(id) {
+                    source = current.payload
+                }
+                let items = _DropItems(location: location, source: source, contents: _DropItems.contents(of: fields["items"]))
+                switch phase {
+                case "entered": targeted(true, items)
+                case "exited": targeted(false, items)
+                case "performed":
+                    targeted(false, items)
+                    _ = perform(items)
+                default: break
+                }
+            }
+        }
+    }
+}
 
 extension View {
-    /// Accepted; the view cannot be dragged in the browser.
-    public func draggable<T: Transferable>(_ payload: @autoclosure @escaping () -> T) -> some View { self }
+    /// The view can be dragged: a long press lifts it on a touch screen, a
+    /// drag does with a mouse. `payload` is made when the drag begins and
+    /// reaches the `dropDestination` (or `onDrop`) it is dropped on.
+    public func draggable<T: Transferable>(_ payload: @autoclosure @escaping () -> T) -> some View {
+        _DraggableView(content: self) { payload() }
+    }
 
-    /// Accepted; the view cannot be dragged in the browser.
+    /// The page drags a copy of the view itself; `preview` is accepted and not drawn.
     public func draggable<T: Transferable, Preview: View>(_ payload: @autoclosure @escaping () -> T,
-                                                          @ViewBuilder preview: () -> Preview) -> some View { self }
+                                                          @ViewBuilder preview: () -> Preview) -> some View {
+        _DraggableView(content: self) { payload() }
+    }
 
-    /// Accepted; nothing is dropped in the browser, so `action` is never called
-    /// and `isTargeted` never reports true.
+    /// The view takes drops of `T`: a dragged view's payload when it is a `T`
+    /// (or exports a type `T` imports), and text, links or files dragged in
+    /// from outside the page that `T` imports. `isTargeted` is told while a
+    /// drag is over the view; `action` gets the values and the drop's point
+    /// in the view's coordinates. Values that import asynchronously reach
+    /// `action` after the drop.
     public func dropDestination<T: Transferable>(for payloadType: T.Type = T.self,
                                                  action: @escaping ([T], CGPoint) -> Bool,
-                                                 isTargeted: @escaping (Bool) -> Void = { _ in }) -> some View { self }
+                                                 isTargeted: @escaping (Bool) -> Void = { _ in }) -> some View {
+        _DropDestinationView(content: self, accepts: _dropAccepts(_Transfer.importedContentTypes(T.self)),
+                             targeted: { targeted, _ in isTargeted(targeted) }) { items in
+            if let value = items.source as? T, items.contents.isEmpty { return action([value], items.location) }
+            let boxed = _UncheckedSendableBox((items, action))
+            Task { @MainActor in
+                let (items, action) = boxed.value
+                let values = await items.values(of: T.self)
+                if !values.isEmpty { _ = action(values, items.location) }
+            }
+            return true
+        }
+    }
 
     /// Accepted; the browser's copy command copies the page's selected text.
     public func copyable<T: Transferable>(_ payload: @autoclosure @escaping () -> [T]) -> some View { self }

package/Sources/SwiftUI/Runtime/Reconciler.swift

@@ -27,16 +27,22 @@ struct _Element {
 
 /// Row metadata the runtime attaches while producing elements and consumes
 /// when it emits a `list`: a `.tag` (or a `ForEach` id, the implicit tag), a
-/// `NavigationLink(value:)`'s value and handler, and the `onDelete` of the
-/// row's `ForEach`.
+/// `NavigationLink(value:)`'s value and handler, and the `onDelete` /
+/// `onMove` of the row's `ForEach`.
 struct _RowMark {
     var tag: AnyHashable?
     var linkValue: AnyHashable?
     var linkHandler: ((_JSON) -> Void)?
     var delete: (() -> Void)?
     var deleteDisabled = false
+    /// The `ForEach`'s `onMove`: (the row's offset, the destination offset).
+    var move: ((Int, Int) -> Void)?
+    /// The `ForEach` node the row belongs to, and the row's offset in its data.
+    var moveGroup: ObjectIdentifier?
+    var moveOffset = 0
+    var moveDisabled = false
 
-    var isEmpty: Bool { tag == nil && linkValue == nil && delete == nil && !deleteDisabled }
+    var isEmpty: Bool { tag == nil && linkValue == nil && delete == nil && !deleteDisabled && move == nil && !moveDisabled }
 
     /// Fills what `self` lacks from an inner element's mark.
     func merged(with inner: _RowMark) -> _RowMark {
@@ -48,6 +54,12 @@ struct _RowMark {
         }
         if result.delete == nil { result.delete = inner.delete }
         result.deleteDisabled = result.deleteDisabled || inner.deleteDisabled
+        if result.move == nil {
+            result.move = inner.move
+            result.moveGroup = inner.moveGroup
+            result.moveOffset = inner.moveOffset
+        }
+        result.moveDisabled = result.moveDisabled || inner.moveDisabled
         return result
     }
 }

package/Sources/SwiftUI/Runtime/Replay.swift

@@ -72,7 +72,7 @@ extension String {
 /// The event types whose first field is a target.
 private let _targetedEvents: Set<String> = [
     "tap", "text", "toggle", "select", "step", "slide", "date", "geometry",
-    "drag", "longpress", "delete", "refresh",
+    "drag", "longpress", "delete", "move", "drop", "refresh",
 ]
 
 /// The element kinds a selector picks for each event type, unless it names
@@ -84,6 +84,9 @@ private let _targetKinds: [String: Set<String>] = [
     "longpress": ["gesture"],
     "drag": ["gesture"],
     "delete": ["listrow"],
+    "move": ["listrow"],
+    "drop": ["dropdestination"],
+    "dragstart": ["draggable"],
     "text": ["textfield", "searchfield", "texteditor"],
     "toggle": ["toggle"],
     "select": ["picker", "tabview"],
@@ -350,6 +353,18 @@ extension _Reconciler {
         return find(in: roots)
     }
 
+    /// The index of the element with this id among its parent's children, if it is on the tree.
+    func containerIndex(of id: Int) -> Int? {
+        func find(in elements: [Rendered]) -> Int? {
+            if let index = elements.firstIndex(where: { $0.id == id }) { return index }
+            for element in elements {
+                if let found = find(in: element.children) { return found }
+            }
+            return nil
+        }
+        return find(in: roots)
+    }
+
     /// `back`: the visible screen's back button.
     func backTarget() throws(_ScriptError) -> Rendered {
         try resolve(_Selector(kind: "navscreen"), for: "tap")

package/Sources/SwiftUI/Runtime/Runtime.swift

@@ -250,7 +250,7 @@ public final class _Runtime {
     private var measuringRoot: _MountedNode?
     /// Set when measurements arrive: the next render re-runs every body, none skipped as unchanged.
     private var renderEverythingPass = false
-    private let reconciler = _Reconciler()
+    let reconciler = _Reconciler()
     private var needsRender = false
     /// The next render re-runs every body (environment changes, `invalidate()`).
     private var fullRender = true
@@ -644,11 +644,14 @@ public final class _Runtime {
             // Host measurement of a custom `Layout`'s children; the handler
             // parses the whole event (see CustomLayout.swift).
             if let id { reconciler.handlers[id]?(event) }
-        case "drag", "longpress", "delete", "refresh", "focus", "submit", "video", "lazy", "menu":
+        case "drag", "longpress", "delete", "move", "refresh", "focus", "submit", "video", "lazy", "menu",
+             "dragstart", "dragend", "drop":
             // Phase 8: the handler receives the whole event and reads `type`
-            // (a `listrow` handles both `tap` and `delete`; Phase 12: a
+            // (a `listrow` handles `tap`, `delete` and `move`; Phase 12: a
             // `textfield` handles `text`, `focus` and `submit`; a `video`
-            // reads its `event`, docs/ops-protocol.md, "Video and audio").
+            // reads its `event`, docs/ops-protocol.md, "Video and audio"; a
+            // `draggable` hears `dragstart` / `dragend` and a
+            // `dropdestination` `drop`, "Drag and drop").
             if let id { reconciler.handlers[id]?(event) }
         case "response":
             // Phase 13: the host's answer to a `request` op.
@@ -997,6 +1000,14 @@ public final class _Runtime {
             if !clean { node.splitSelection = nil }
             let sidebar = _SplitSidebarView(content: split._sidebar, split: node)
             if context.environment.horizontalSizeClass == .regular {
+                // The sidebar toggle (a `tap` on the split view) shows or
+                // hides the sidebar, sliding the columns.
+                let visibility = split._columnVisibility
+                node.handler = { _ in
+                    withAnimation(.default) {
+                        visibility.wrappedValue = visibility.wrappedValue._showsSidebar ? .detailOnly : .all
+                    }
+                }
                 // Two columns, each its own stack; they are not nested in a
                 // screen even when the split view is, so they are not flattened.
                 context.navStack = nil
@@ -1585,11 +1596,12 @@ public final class _Runtime {
             // `navstack` whose screens are the sidebar, the detail and what
             // the detail pushed.
             let regular = node.environment.horizontalSizeClass == .regular
+            let shows = (node.view as? any _NavigationSplitHost)?._columnVisibility.wrappedValue._showsSidebar ?? true
             produced = [_Element(
                 kind: regular ? "navsplit" : "navstack",
-                props: .object([:]),
+                props: regular ? .object(["sidebarVisible": .bool(shows)]) : .object([:]),
                 children: node.children.flatMap(elements(of:)),
-                handler: nil
+                handler: regular ? node.handler : nil
             )]
         } else if traits.contains(.navigationStack), node.navFlattened {
             produced = node.children.flatMap(elements(of:))
@@ -1681,9 +1693,11 @@ public final class _Runtime {
                 produced[index].row = (produced[index].row ?? _RowMark()).merged(with: _RowMark(tag: tag))
             }
         }
-        if traits.contains(.rowEditingDisabling), let disabling = node.view as? any _RowEditingDisabling, disabling._deleteDisabled {
+        if traits.contains(.rowEditingDisabling), let disabling = node.view as? any _RowEditingDisabling,
+           disabling._deleteDisabled || disabling._moveDisabled {
+            let mark = _RowMark(deleteDisabled: disabling._deleteDisabled, moveDisabled: disabling._moveDisabled)
             for index in produced.indices {
-                produced[index].row = (produced[index].row ?? _RowMark()).merged(with: _RowMark(deleteDisabled: true))
+                produced[index].row = (produced[index].row ?? _RowMark()).merged(with: mark)
             }
         }
         if traits.contains(.layoutValueProviding), let providing = node.view as? any _LayoutValueProviding {
@@ -1722,11 +1736,15 @@ public final class _Runtime {
     /// the siblings. Without that the element diff matched the two groups'
     /// elements to each other on alternate passes, swapping their props.
     private func childElements(of node: _MountedNode) -> [_Element] {
-        let delete = _ViewTraits.of(node.view).contains(.deletableGroup) ? (node.view as? any _DeletableGroup)?._delete : nil
+        let editable = _ViewTraits.of(node.view).contains(.deletableGroup) ? node.view as? any _DeletableGroup : nil
+        let delete = editable?._delete
+        let move = editable?._move
+        let group = ObjectIdentifier(node)
         return node.children.enumerated().flatMap { position, child -> [_Element] in
             var items = elements(of: child)
-            // A `ForEach` id is the row's implicit tag; an `onDelete` group's
-            // child at `position` is the row at that offset of its data.
+            // A `ForEach` id is the row's implicit tag; an `onDelete` /
+            // `onMove` group's child at `position` is the row at that offset
+            // of its data.
             if let key = child.key {
                 for index in items.indices where items[index].row?.tag == nil {
                     items[index].row = (items[index].row ?? _RowMark()).merged(with: _RowMark(tag: key))
@@ -1737,6 +1755,11 @@ public final class _Runtime {
                     items[index].row = (items[index].row ?? _RowMark()).merged(with: _RowMark(delete: { delete(position) }))
                 }
             }
+            if let move {
+                for index in items.indices where items[index].row?.move == nil {
+                    items[index].row = (items[index].row ?? _RowMark()).merged(with: _RowMark(move: move, moveGroup: group, moveOffset: position))
+                }
+            }
             if child.key == nil, _ViewTraits.of(child.view).contains(.group), let group = child.view as? any _GroupView, group._keys != nil {
                 for index in items.indices {
                     if let key = items[index].key {
@@ -1748,15 +1771,19 @@ public final class _Runtime {
         }
     }
 
-    /// Wraps a `list`'s rows (also those of its `section`s) that can be selected
-    /// or deleted in `listrow` elements (docs/ops-protocol.md, Phase 8). A row
+    /// Wraps a `list`'s rows (also those of its `section`s) that can be selected,
+    /// deleted or moved in `listrow` elements (docs/ops-protocol.md, Phase 8). A row
     /// is selectable when the list has a selection and the row's `.tag`,
     /// `ForEach` id or `NavigationLink(value:)` is of the selection's type;
     /// deletable when its `ForEach` has `onDelete` and the row is not
-    /// `deleteDisabled`. The row's key moves to the wrapper.
+    /// `deleteDisabled`; movable when its `ForEach` has `onMove` and the row
+    /// is not `moveDisabled`. The row's key moves to the wrapper.
     private func wrapListRows(_ elements: [_Element], in node: _MountedNode) -> [_Element] {
         let selection = node.environment._listSelection
         let editMode = node.environment.editMode
+        // Which `ForEach` each child belongs to, by position: a `move` event's
+        // destination counts the children of the moved row's group before it.
+        let groups = elements.map { $0.row?.moveGroup }
         return elements.map { element in
             if element.kind == "section" {
                 var section = element
@@ -1767,7 +1794,8 @@ public final class _Runtime {
             let value = mark.linkValue ?? mark.tag
             let selectable: Bool = if let selection, let value { selection.accepts(value) } else { false }
             let deletable = mark.delete != nil && !mark.deleteDisabled
-            guard selectable || deletable else { return element }
+            let movable = mark.move != nil && !mark.moveDisabled
+            guard selectable || deletable || movable else { return element }
             let selected = selectable && selection!.contains(value!)
 
             var inner = element
@@ -1778,6 +1806,18 @@ public final class _Runtime {
                     if deletable { mark.delete?() }
                     return
                 }
+                if case .object(let fields) = payload, case .string("move")? = fields["type"] {
+                    // `to`: the index among the container's children before
+                    // which the row goes, counted before it leaves (as
+                    // `move(fromOffsets:toOffset:)` takes its destination).
+                    // In the group's data that is the number of the group's
+                    // rows before that index.
+                    guard movable, let move = mark.move, case .number(let to)? = fields["to"] else { return }
+                    let bound = Swift.max(0, Swift.min(Int(to), groups.count))
+                    let destination = groups[0..<bound].filter { $0 == mark.moveGroup }.count
+                    move(mark.moveOffset, destination)
+                    return
+                }
                 guard selectable, let selection, let value else {
                     mark.linkHandler?(.null)
                     return
@@ -1792,13 +1832,15 @@ public final class _Runtime {
                     selection.set(value)
                 }
             }
+            var props: [String: _JSON] = [
+                "selectable": .bool(selectable),
+                "selected": .bool(selected),
+                "deletable": .bool(deletable),
+            ]
+            if movable { props["movable"] = .bool(true) }
             return _Element(
                 kind: "listrow",
-                props: .object([
-                    "selectable": .bool(selectable),
-                    "selected": .bool(selected),
-                    "deletable": .bool(deletable),
-                ]),
+                props: .object(props),
                 children: [inner],
                 handler: handler,
                 key: element.key
@@ -1843,7 +1885,9 @@ public final class _Runtime {
     /// `text:"Name":Milk`, `toggle:"Done":true`, `select:"Sort":"Title"`,
     /// `env:dark`, `type:xxxLarge`, `size:regular`, `step:"8 hours":1`,
     /// `slide:7:0.35`, `date:7:1700000000`, `drag:12:changed:40x-3`,
-    /// `longpress:12`, `delete:"Coffee"`, `refresh:40`, `back`, `dismiss`.
+    /// `longpress:12`, `delete:"Coffee"`, `move:"Coffee":2` /
+    /// `move:"Coffee":"Lunch"`, `drop:"Trash":"Coffee"` / `drop:"Trash":Hello`,
+    /// `refresh:40`, `back`, `dismiss`.
     /// Each is echoed, with the id its target resolved to, before its ops.
     /// Returns false, after printing an error op, at the first event that
     /// cannot be parsed or whose selector does not name exactly one element.
@@ -1863,6 +1907,13 @@ public final class _Runtime {
                 print(_JSON.object(["op": .string("error"), "message": .string(error.message)]).serialized)
                 return false
             }
+            if event["type"] == .string("drop"), case .number(let source)? = event["source"] {
+                dispatch(event: .object(["type": .string("dragstart"), "id": .number(source)]))
+                host.apply([.event(.object(event))])
+                dispatch(event: .object(event))
+                dispatch(event: .object(["type": .string("dragend"), "id": .number(source)]))
+                continue
+            }
             host.apply([.event(.object(event))])
             dispatch(event: .object(event))
         }
@@ -1938,6 +1989,30 @@ public final class _Runtime {
             guard rest.count == 2 else { throw unrecognized }
             event["phase"] = .string(rest[0])
             event["translation"] = try size(rest[1])
+        case "move":
+            // move:"Coffee":2 (the index among the row's container's children
+            // before which it goes) or move:"Coffee":"Lunch" (before that row).
+            if parsed.valueQuoted, let text = value {
+                let row = try reconciler.resolve(_Selector(text: text), for: "move")
+                guard let index = reconciler.containerIndex(of: row.id) else { throw unrecognized }
+                event["to"] = .number(Double(index))
+            } else {
+                event["to"] = try number(value)
+            }
+        case "drop":
+            // drop:"Trash":"Coffee" (the draggable showing Coffee, dropped on
+            // the destination showing Trash) or drop:"Trash":Hello (the text
+            // "Hello" dropped from outside the page). A dragged source starts
+            // and ends its drag around the drop (replayed as three events).
+            event["phase"] = .string("performed")
+            event["x"] = .number(0)
+            event["y"] = .number(0)
+            if parsed.valueQuoted, let text = value {
+                let source = try reconciler.resolve(_Selector(text: text), for: "dragstart")
+                event["source"] = .number(Double(source.id))
+            } else {
+                event["items"] = .array([.object(["type": .string("text/plain"), "text": .string(value ?? "")])])
+            }
         default:
             throw unrecognized
         }

package/Sources/UIKit/Font.swift

@@ -34,13 +34,14 @@ open class UIFont: NSObject, NSSecureCoding, @unchecked Sendable {
     // MARK: Metrics (SF Pro's, per point)
 
     public var familyName: String { design == .rounded ? ".AppleSystemUIFontRounded" : ".AppleSystemUIFont" }
-    public var ascender: CGFloat { pointSize * 0.952 }
-    public var descender: CGFloat { -pointSize * 0.241 }
+    public var ascender: CGFloat { pointSize * 1950 / 2048 }
+    public var descender: CGFloat { -pointSize * 494 / 2048 }
     public var capHeight: CGFloat { pointSize * 0.705 }
     public var xHeight: CGFloat { pointSize * 0.53 }
     public var leading: CGFloat { 0 }
-    /// The line height iOS uses for the standard sizes (17 → 22), else 1.2 × the size.
-    public var lineHeight: CGFloat { UIFont.standardLineHeights[pointSize] ?? (pointSize * 1.2).rounded() }
+    /// The ascender plus the descender, as on iOS (17 → 20.29); SwiftUI makes
+    /// a line of `Text` this tall, rounded up to a pixel (typography.ts).
+    public var lineHeight: CGFloat { ascender - descender }
 
     public var fontDescriptor: UIFontDescriptor {
         UIFontDescriptor(fontName: fontName, pointSize: pointSize, weight: weight, design: design)
@@ -128,8 +129,6 @@ open class UIFont: NSObject, NSSecureCoding, @unchecked Sendable {
         super.init()
     }
 
-    static let standardLineHeights: [CGFloat: CGFloat] = [34: 41, 28: 34, 22: 28, 20: 25, 17: 22, 16: 21, 15: 20, 13: 18, 12: 16, 11: 13]
-
     // MARK: Nested types
 
     public struct Weight: RawRepresentable, Hashable, Sendable {

package/Sources/UIKit/TextView.swift

@@ -159,7 +159,9 @@ enum _TextEstimate {
         }
         if maximumLines > 0 { lines = min(lines, maximumLines) }
         let resolvedWidth = width.flatMap { $0 > 0 && $0.isFinite ? min($0, widest) : nil } ?? widest
-        return CGSize(width: resolvedWidth.rounded(.up), height: CGFloat(max(1, lines)) * font.lineHeight)
+        // Whole 3x pixels, as iOS rounds a text's size up.
+        let height = (CGFloat(max(1, lines)) * font.lineHeight * 3).rounded(.up) / 3
+        return CGSize(width: resolvedWidth.rounded(.up), height: height)
     }
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@swiftbrowser/swift",
-  "version": "0.3.1",
+  "version": "0.5.0",
   "description": "The SwiftBrowser Swift package (the SwiftUI shim, Charts, SwiftData and FoundationBridge) as an npm package, so @swiftbrowser/cli builds apps against the exact version it ships with.",
   "repository": {
     "type": "git",