diff --git a/Sources/OpenSwiftUI/Integration/PlatformItems/PlatformItemsReader.swift b/Sources/OpenSwiftUI/Integration/PlatformItems/PlatformItemsReader.swift
new file mode 100644
index 000000000..974b1c2fb
--- /dev/null
+++ b/Sources/OpenSwiftUI/Integration/PlatformItems/PlatformItemsReader.swift
@@ -0,0 +1,136 @@
+//
+//  PlatformItemsReader.swift
+//  OpenSwiftUI
+//
+//  Audited for 6.5.4
+//  Status: Complete
+//  ID: 2D2DE8D65225CC97305A8AAD72170302 (SwiftUI)
+
+import OpenAttributeGraphShims
+@_spi(ForOpenSwiftUIOnly) import OpenSwiftUICore
+
+// MARK: - PlatformItemsReader
+
+struct PlatformItemsReader<Strategy, Content, Source>: PrimitiveView, UnaryView
+    where Strategy: PlatformItemsStrategy, Content: View, Source: View {
+    var content: (Strategy.Content) -> Content
+    var source: ZStack<Source>
+
+    init(
+        for strategy: Strategy,
+        @ViewBuilder content: @escaping (Strategy.Content) -> Content,
+        @ViewBuilder source: () -> Source
+    ) {
+        self.content = content
+        self.source = ZStack(content: source)
+    }
+
+    static func _makeView(view: _GraphValue<Self>, inputs: _ViewInputs) -> _ViewOutputs {
+        let source = view[offset: { .of(&$0.source) }]
+        let hostKeys = inputs.intern(PreferenceKeys(), id: .defaultValue)
+        var sourceInputs = inputs.withoutGeometryDependencies
+        sourceInputs.preferences = PreferencesInputs(hostKeys: hostKeys)
+        Strategy.makeInputs(&sourceInputs)
+        let outputs = ZStack<Source>.makeDebuggableView(
+            view: source,
+            inputs: sourceInputs
+        )
+        let child = Child(
+            content: Strategy.makeContent(from: outputs),
+            viewContent: view.value[offset: { .of(&$0.content) }],
+            oldContent: Strategy.defaultValue
+        )
+        return Content.makeDebuggableView(view: _GraphValue(child), inputs: inputs)
+    }
+
+    private struct Child: StatefulRule {
+        @OptionalAttribute var content: Strategy.Content?
+        @Attribute var viewContent: (Strategy.Content) -> Content
+        var oldContent: Strategy.Content
+
+        typealias Value = Content
+
+        init(
+            content: OptionalAttribute<Strategy.Content>,
+            viewContent: Attribute<(Strategy.Content) -> Content>,
+            oldContent: Strategy.Content
+        ) {
+            self._content = content
+            self._viewContent = viewContent
+            self.oldContent = oldContent
+        }
+
+        mutating func updateValue() {
+            let (viewContent, viewChanged) = $viewContent.changedValue()
+            let (content, contentChanged) = $content?.changedValue() ?? (Strategy.defaultValue, false)
+            defer { oldContent = content }
+            let changed = Strategy.hasChanges(from: oldContent, to: content)
+            guard !hasValue || (contentChanged && changed) || viewChanged else {
+                return
+            }
+            value = withObservation {
+                viewContent(content)
+            }
+        }
+    }
+}
+
+// MARK: - PlatformItemTraitWriter
+
+struct PlatformItemTraitWriter<Strategy, Source, Trait>: PrimitiveViewModifier
+    where Strategy: UnaryPlatformItemsStrategy, Source: View,
+          Trait: _ViewTraitKey, Trait.Value == PlatformItem {
+    var source: Source
+
+    nonisolated static func _makeView(
+        modifier: _GraphValue<Self>,
+        inputs: _ViewInputs,
+        body: @escaping (_Graph, _ViewInputs) -> _ViewOutputs
+    ) -> _ViewOutputs {
+        body(_Graph(), inputs)
+    }
+
+    nonisolated static func _makeViewList(
+        modifier: _GraphValue<Self>,
+        inputs: _ViewListInputs,
+        body: @escaping (_Graph, _ViewListInputs) -> _ViewListOutputs
+    ) -> _ViewListOutputs {
+        var childInputs = inputs
+        var sourceInputs = inputs.withoutGeometryDependencies
+        Strategy.makeInputs(&sourceInputs)
+        let source = modifier[offset: { .of(&$0.source) }]
+        let outputs = Source._makeView(
+            view: source,
+            inputs: sourceInputs
+        )
+        let addTrait = AddTrait(
+            content: .init(outputs.platformItem),
+            traits: .init(inputs.traits),
+            oldContent: Strategy.defaultValue
+        )
+        childInputs.traits = Attribute(addTrait)
+        childInputs.addTraitKey(Trait.self)
+        return body(_Graph(), childInputs)
+    }
+
+    private struct AddTrait: StatefulRule, AsyncAttribute {
+        @OptionalAttribute var content: PlatformItem?
+        @OptionalAttribute var traits: ViewTraitCollection?
+        var oldContent: PlatformItem
+
+        typealias Value = ViewTraitCollection
+
+        mutating func updateValue() {
+            let (content, contentChanged) = $content?.changedValue() ?? (Strategy.defaultValue, false)
+            let (incomingTraits, traitsChanged) = $traits?.changedValue() ?? (ViewTraitCollection(), false)
+            defer { oldContent = content }
+            let changed = Strategy.hasChanges(from: oldContent, to: content)
+            guard !hasValue || (contentChanged && changed) || traitsChanged else {
+                return
+            }
+            var traits = incomingTraits
+            traits[Trait.self] = content
+            value = traits
+        }
+    }
+}
diff --git a/Sources/OpenSwiftUI/Integration/PlatformItems/PlatformItemsStrategy.swift b/Sources/OpenSwiftUI/Integration/PlatformItems/PlatformItemsStrategy.swift
index b721a1e54..f198167c9 100644
--- a/Sources/OpenSwiftUI/Integration/PlatformItems/PlatformItemsStrategy.swift
+++ b/Sources/OpenSwiftUI/Integration/PlatformItems/PlatformItemsStrategy.swift
@@ -3,7 +3,7 @@
 //  OpenSwiftUI
 //
 //  Audited for 6.5.4
-//  Status: WIP
+//  Status: Complete
 
 import OpenAttributeGraphShims
 import OpenSwiftUICore
@@ -21,3 +21,96 @@ protocol PlatformItemsStrategy {
     static func makeInputs(_ inputs: inout _ViewInputs)
     static func makeContent(from outputs: _ViewOutputs) -> OptionalAttribute<Content>
 }
+
+// MARK: - MultiPlatformItemsStrategy
+
+protocol MultiPlatformItemsStrategy: PlatformItemsStrategy where Content == PlatformItems {}
+
+extension MultiPlatformItemsStrategy {
+    static var defaultValue: PlatformItems { .init(features: itemsFeatures) }
+
+    static var itemsFeatures: PlatformItems.Features { .multiple }
+
+    static func hasChanges(from oldContent: PlatformItems, to newContent: PlatformItems) -> Bool {
+        oldContent.seed.matches(newContent.seed) && oldContent.id == newContent.id
+    }
+
+    static func makeInputs(_ inputs: inout _ViewInputs) {
+        inputs.preferences.requiresPlatformItems = true
+        inputs.requestedTextRepresentation = PlatformItemsTextRepresentable.self
+        inputs.requestedImageRepresentation = PlatformItemsImageRepresentable.self
+        inputs.platformItemsFeatures.formUnion(itemsFeatures)
+        inputs.platformItemFeatures.formUnion(itemFeatures)
+        inputs.requestsPlatformItems = true
+    }
+
+    static func makeContent(from outputs: _ViewOutputs) -> OptionalAttribute<PlatformItems> {
+        .init(outputs.preferences.platformItems)
+    }
+}
+
+// MARK: - UnaryPlatformItemsStrategy
+
+protocol UnaryPlatformItemsStrategy: PlatformItemsStrategy where Content == PlatformItem {}
+
+extension UnaryPlatformItemsStrategy {
+    static var defaultValue: PlatformItem { .init(id: .init(ids: [.invalid])) }
+
+    static var itemsFeatures: PlatformItems.Features { [] }
+
+    static func hasChanges(from oldContent: PlatformItem, to newContent: PlatformItem) -> Bool {
+        !oldContent.seed.matches(newContent.seed) || oldContent.id != newContent.id
+    }
+
+    static func makeInputs(_ inputs: inout _ViewInputs) {
+        inputs.preferences.requiresPlatformItems = true
+        inputs.requestedTextRepresentation = PlatformItemsTextRepresentable.self
+        inputs.requestedImageRepresentation = PlatformItemsImageRepresentable.self
+        inputs.platformItemsFeatures.formUnion(itemsFeatures)
+        inputs.platformItemFeatures.formUnion(itemFeatures)
+        inputs.requestsPlatformItems = true
+        if itemFeatures.contains(.accessibility) {
+            inputs.preferences.add(AccessibilityAttachment.Key.self)
+        }
+    }
+
+    static func makeContent(from outputs: _ViewOutputs) -> OptionalAttribute<PlatformItem> {
+        .init(outputs.platformItem)
+    }
+}
+
+// MARK: - MultiButtonPlatformItemsStrategy
+
+struct MultiButtonPlatformItemsStrategy: MultiPlatformItemsStrategy {
+    static var itemFeatures: PlatformItem.Features {
+        [.text, .image, .selection, .secondaryText]
+    }
+}
+
+// MARK: - LabelPlatformItemsStrategy
+
+struct LabelPlatformItemsStrategy: UnaryPlatformItemsStrategy {
+    static var itemFeatures: PlatformItem.Features {
+        [.text, .image, .secondaryText, .iconText, .accessibility]
+    }
+}
+
+// MARK: - TextPlatformItemsStrategy
+
+struct TextPlatformItemsStrategy: UnaryPlatformItemsStrategy {
+    static var itemFeatures: PlatformItem.Features { .text }
+}
+
+// MARK: - ButtonPlatformItemsStrategy
+
+struct ButtonPlatformItemsStrategy: UnaryPlatformItemsStrategy {
+    static var itemFeatures: PlatformItem.Features {
+        [.text, .image, .selection, .secondaryText]
+    }
+}
+
+// MARK: - StyledTextPlatformItemsStrategy
+
+struct StyledTextPlatformItemsStrategy: UnaryPlatformItemsStrategy {
+    static var itemFeatures: PlatformItem.Features { [.text, .styledText] }
+}
diff --git a/Sources/OpenSwiftUI/View/Control/Button/DefaultButtonStyle.swift b/Sources/OpenSwiftUI/View/Control/Button/DefaultButtonStyle.swift
index 5d9113d84..95a34b074 100644
--- a/Sources/OpenSwiftUI/View/Control/Button/DefaultButtonStyle.swift
+++ b/Sources/OpenSwiftUI/View/Control/Button/DefaultButtonStyle.swift
@@ -68,7 +68,10 @@ public struct DefaultButtonStyle: PrimitiveButtonStyle {
             // TODO: macOS ToolbarButtonStyle in ToolbarStyleContext.
             // TODO: macOS SheetToolbarButtonStyle in SheetToolbarStyleContext.
             // TODO: macOS ListAccessoryBarButtonStyle in ListAccessoryBarStyleContext.
-            // TODO: SidebarSectionActionButtonStyle in SidebarSectionActionStyleContext.
+            .modifier(
+                PrimitiveButtonStyleContainerModifier(style: SidebarSectionActionButtonStyle())
+                    .requiring(SidebarSectionActionStyleContext.self)
+            )
             .modifier(
                 PrimitiveButtonStyleContainerModifier(style: PlatformItemListButtonStyle())
                     .requiring(AccessibilityQuickActionStyleContext.self)
diff --git a/Sources/OpenSwiftUI/View/Control/Button/SidebarSectionActionButtonStyle_Mac.swift b/Sources/OpenSwiftUI/View/Control/Button/SidebarSectionActionButtonStyle_Mac.swift
new file mode 100644
index 000000000..9393a4e5d
--- /dev/null
+++ b/Sources/OpenSwiftUI/View/Control/Button/SidebarSectionActionButtonStyle_Mac.swift
@@ -0,0 +1,27 @@
+//
+//  SidebarSectionActionButtonStyle_Mac.swift
+//  OpenSwiftUI
+//
+//  Audited for 6.5.4
+//  Status: Complete
+
+#if os(macOS)
+import OpenSwiftUICore
+
+struct SidebarSectionActionButtonStyle_Mac: ButtonStyle {
+    func makeBody(configuration: Configuration) -> some View {
+        configuration.label
+            .frame(minWidth: 12, minHeight: 12)
+            .contentShape(Rectangle())
+            .labelStyle(.iconOnly)
+            .defaultForegroundStyle(
+                configuration.isPressed
+                    ? HierarchicalShapeStyle.secondary
+                    : HierarchicalShapeStyle.tertiary
+            )
+            .help {
+                configuration.label
+            }
+    }
+}
+#endif
diff --git a/Sources/OpenSwiftUI/View/Help/HelpStyle.swift b/Sources/OpenSwiftUI/View/Help/HelpStyle.swift
new file mode 100644
index 000000000..e539bf0a2
--- /dev/null
+++ b/Sources/OpenSwiftUI/View/Help/HelpStyle.swift
@@ -0,0 +1,133 @@
+//
+//  HelpStyle.swift
+//  OpenSwiftUI
+//
+//  Audited for 6.5.4
+//  Status: Complete
+//  ID: 2E9CED02B61F68F209568461F8033B51 (SwiftUI)
+
+public import OpenSwiftUICore
+
+// MARK: - HelpStyle
+
+@_spi(UIFrameworks)
+@available(OpenSwiftUI_v4_0, *)
+@preconcurrency
+@MainActor
+public protocol HelpStyle {
+    associatedtype Body: View
+
+    @ViewBuilder
+    func makeBody(configuration: Configuration) -> Body
+
+    typealias Configuration = HelpStyleConfiguration
+}
+
+// MARK: - HelpStyleConfiguration
+
+@_spi(UIFrameworks)
+@available(OpenSwiftUI_v4_0, *)
+public struct HelpStyleConfiguration {
+    public struct Content: ViewAlias {
+        public typealias Body = Never
+
+        nonisolated package init() {
+            _openSwiftUIEmptyStub()
+        }
+    }
+
+    public let content: Content = .init()
+    public let text: Text
+}
+
+@_spi(UIFrameworks)
+@available(*, unavailable)
+extension HelpStyleConfiguration.Content: Sendable {}
+
+@_spi(UIFrameworks)
+@available(*, unavailable)
+extension HelpStyleConfiguration: Sendable {}
+
+// MARK: - HelpView
+
+struct HelpView<Content>: View where Content: View {
+    var content: Content
+    var text: Text
+
+    init(content: Content, text: Text) {
+        self.content = content
+        self.text = text
+    }
+
+    var body: some View {
+        ResolvedHelpStyle(configuration: .init(text: text))
+            .viewAlias(HelpStyleConfiguration.Content.self) {
+                content
+            }
+    }
+}
+
+// MARK: - ResolvedHelpStyle
+
+private struct ResolvedHelpStyle: StyleableView {
+    var configuration: HelpStyleConfiguration
+
+    static var defaultStyleModifier: HelpStyleModifier<DefaultHelpStyle> {
+        .init(style: DefaultHelpStyle())
+    }
+
+    var body: some View {
+        HelpView(content: configuration.content, text: configuration.text)
+            .accessibility(AccessibilityProperties.HintsKey.self, [configuration.text])
+    }
+}
+
+// MARK: - EmptyHelpStyle
+
+private struct EmptyHelpStyle: HelpStyle {
+    func makeBody(configuration: Configuration) -> some View {
+        configuration.content
+    }
+}
+
+// MARK: - TooltipHelpStyle
+
+private struct TooltipHelpStyle: HelpStyle {
+    func makeBody(configuration: Configuration) -> some View {
+        configuration.content
+            .modifier(TooltipModifier(text: configuration.text))
+    }
+}
+
+// MARK: - DefaultHelpStyle
+
+struct DefaultHelpStyle: HelpStyle, AnyDefaultStyle {
+    func makeBody(configuration: Configuration) -> some View {
+        HelpView(content: configuration.content, text: configuration.text)
+            .helpStyle(TooltipHelpStyle())
+            .helpStyle(EmptyHelpStyle())
+    }
+}
+
+// MARK: - View + helpStyle
+
+extension View {
+    @inline(__always)
+    func helpStyle<S>(_ style: S) -> some View where S: HelpStyle {
+        modifier(HelpStyleModifier(style: style))
+    }
+}
+
+// MARK: - HelpStyleModifier
+
+struct HelpStyleModifier<S>: StyleModifier where S: HelpStyle {
+    var style: S
+
+    init(style: S) {
+        self.style = style
+    }
+
+    func styleBody(configuration: HelpStyleConfiguration) -> some View {
+        style.makeBody(configuration: configuration)
+    }
+}
diff --git a/Sources/OpenSwiftUI/View/Help/HelpTag.swift b/Sources/OpenSwiftUI/View/Help/HelpTag.swift
new file mode 100644
index 000000000..e221b3a34
--- /dev/null
+++ b/Sources/OpenSwiftUI/View/Help/HelpTag.swift
@@ -0,0 +1,86 @@
+//
+//  HelpTag.swift
+//  OpenSwiftUI
+//
+//  Audited for 6.5.4
+//  Status: Complete
+//  ID: 7529EF7F24AB68C916419BA46B1AEA8F (SwiftUI)
+
+public import OpenSwiftUICore
+
+@available(OpenSwiftUI_v2_0, *)
+extension View {
+    /// Adds help text to a view using a localized string that you provide.
+    ///
+    /// Adding help to a view configures the view's accessibility hint and
+    /// its help tag (also called a _tooltip_) in macOS or visionOS.
+    /// For more information on using help tags, see
+    /// [Offering help](https://developer.apple.com/design/human-interface-guidelines/offering-help)
+    /// in the Human Interface Guidelines.
+    ///
+    ///     Button(action: composeMessage) {
+    ///         Image(systemName: "square.and.pencil")
+    ///     }
+    ///     .help("Compose a new message")
+    ///
+    /// - Parameter textKey: The key for the localized text to use as help.
+    nonisolated public func help(_ textKey: LocalizedStringKey) -> some View {
+        HelpView(content: self, text: Text(textKey))
+    }
+
+    /// Adds help text to a view using a text view that you provide.
+    ///
+    /// Adding help to a view configures the view's accessibility hint and
+    /// its help tag (also called a _tooltip_) in macOS or visionOS.
+    /// For more information on using help tags, see
+    /// [Offering help](https://developer.apple.com/design/human-interface-guidelines/offering-help)
+    /// in the Human Interface Guidelines.
+    ///
+    ///     Slider("Opacity", value: $selectedShape.opacity)
+    ///         .help(Text("Adjust the opacity of the selected \(selectedShape.name)"))
+    ///
+    /// - Parameter text: The ``Text`` view to use as help.
+    nonisolated public func help(_ text: Text) -> some View {
+        HelpView(content: self, text: text)
+    }
+
+    /// Adds help text to a view using a string that you provide.
+    ///
+    /// Adding help to a view configures the view's accessibility hint and
+    /// its help tag (also called a _tooltip_) in macOS or visionOS.
+    /// For more information on using help tags, see
+    /// [Offering help](https://developer.apple.com/design/human-interface-guidelines/offering-help)
+    /// in the Human Interface Guidelines.
+    ///
+    ///     Image(systemName: "pin.circle")
+    ///         .foregroundColor(pointOfInterest.tintColor)
+    ///         .help(pointOfInterest.name)
+    ///
+    /// - Parameter text: The text to use as help.
+    @_disfavoredOverload
+    nonisolated public func help<S>(_ text: S) -> some View where S: StringProtocol {
+        HelpView(content: self, text: Text(text))
+    }
+}
+
+#if os(macOS)
+extension View {
+    @inline(__always)
+    func help<Label>(@ViewBuilder _ label: () -> Label) -> some View where Label: View {
+        ViewBasedHelpView(content: self, label: label())
+    }
+}
+
+private struct ViewBasedHelpView<Content, Label>: View where Content: View, Label: View {
+    var content: Content
+    var label: Label
+
+    var body: some View {
+        PlatformItemsReader(for: TextPlatformItemsStrategy()) { item in
+            HelpView(content: content, text: Text(item.content?.text?.string ?? ""))
+        } source: {
+            label
+        }
+    }
+}
+#endif
diff --git a/Sources/OpenSwiftUI/View/Help/TooltipModifier.swift b/Sources/OpenSwiftUI/View/Help/TooltipModifier.swift
new file mode 100644
index 000000000..985a77d23
--- /dev/null
+++ b/Sources/OpenSwiftUI/View/Help/TooltipModifier.swift
@@ -0,0 +1,139 @@
+//
+//  TooltipModifier.swift
+//  OpenSwiftUI
+//
+//  Audited for 6.5.4
+//  Status: WIP
+//  ID: 260978DE3FF5445B342BD9F05199EF00 (SwiftUI)
+
+import Foundation
+import OpenAttributeGraphShims
+@_spi(ForOpenSwiftUIOnly)
+@_spi(Private)
+import OpenSwiftUICore
+
+// MARK: - TooltipResponder
+
+class TooltipResponder: DefaultLayoutViewResponder {
+    fileprivate var _text: OptionalAttribute<String> = .init()
+    var position: CGPoint = .zero
+    var size: CGSize = .invalidValue
+    var transform: ViewTransform = .init()
+
+    var text: String? {
+        Update.dispatchImmediately(reason: nil) {
+            Graph.withoutUpdate {
+                guard let text = _text.wrappedValue, !text.isEmpty else {
+                    return nil
+                }
+                return text
+            }
+        }
+    }
+
+    override func extendPrintTree(string: inout String) {
+        string += "tooltip (\(text ?? "nil"))"
+    }
+}
+
+// MARK: - HasTooltipKey
+
+struct HasTooltipKey: HostPreferenceKey {
+    static var defaultValue: Bool { false }
+
+    static func reduce(value: inout Bool, nextValue: () -> Bool) {
+        value = value || nextValue()
+    }
+}
+
+// MARK: - TooltipModifier
+
+struct TooltipModifier: PrimitiveViewModifier, MultiViewModifier {
+    var text: Text
+
+    static func _makeView(
+        modifier: _GraphValue<Self>,
+        inputs: _ViewInputs,
+        body: @escaping (_Graph, _ViewInputs) -> _ViewOutputs
+    ) -> _ViewOutputs {
+        var outputs = body(_Graph(), inputs)
+        let text = Attribute(ResolveText(modifier: modifier.value, environment: inputs.environment))
+        if inputs.platformItemListFlags.contains(.layout) {
+            outputs.transformPlatformItemList(
+                inputs: inputs,
+                transform: Attribute(TransformPlatformItems(text: text))
+            )
+        }
+        guard inputs.preferences.requiresDisplayList else {
+            return outputs
+        }
+        if Semantics.ResponderBasedTooltips.isEnabled {
+            if inputs.preferences.requiresViewResponders {
+                outputs.preferences.makePreferenceWriter(
+                    inputs: inputs.preferences,
+                    key: HasTooltipKey.self,
+                    value: inputs.intern(true, id: .trueValue)
+                )
+                outputs.preferences.viewResponders = Attribute(TooltipResponderUpdater(
+                    responder: TooltipResponder(inputs: inputs),
+                    children: outputs.viewResponders(),
+                    text: text,
+                    position: inputs.animatedPosition(),
+                    size: inputs.animatedSize(),
+                    transform: inputs.transform
+                ))
+            }
+        }
+        // TODO: PointerHost and PointerRegionUpdater for legacy macOS tooltip semantics.
+        _openSwiftUIUnimplementedWarning()
+        return outputs
+    }
+
+    private struct TransformPlatformItems: Rule {
+        @Attribute var text: String
+
+        var value: (inout PlatformItemList) -> Void {
+            { list in
+                for index in list.items.indices {
+                    list.items[index].tooltip = text
+                }
+            }
+        }
+    }
+
+    private struct TooltipResponderUpdater: StatefulRule {
+        let responder: TooltipResponder
+        @Attribute var children: [ViewResponder]
+        @Attribute var text: String
+        @Attribute var position: CGPoint
+        @Attribute var size: ViewSize
+        @Attribute var transform: ViewTransform
+
+        typealias Value = [ViewResponder]
+
+        mutating func updateValue() {
+            responder._text = OptionalAttribute($text)
+            let (position, positionChanged) = $position.changedValue()
+            let (size, sizeChanged) = $size.changedValue()
+            let (transform, transformChanged) = $transform.changedValue()
+            if positionChanged || sizeChanged || transformChanged || !hasValue {
+                responder.position = position
+                responder.size = size.value
+                responder.transform = transform
+            }
+            responder.updateChildren($children.changedValue())
+            if !hasValue {
+                value = [responder]
+            }
+        }
+    }
+
+    private struct ResolveText: Rule {
+        @Attribute var modifier: TooltipModifier
+        @Attribute var environment: EnvironmentValues
+
+        var value: String {
+            modifier.text.resolveString(in: environment)
+        }
+    }
+}
diff --git a/Sources/OpenSwiftUI/View/List/ListStyle.swift b/Sources/OpenSwiftUI/View/List/ListStyle.swift
index 42eacdf0c..737d46877 100644
--- a/Sources/OpenSwiftUI/View/List/ListStyle.swift
+++ b/Sources/OpenSwiftUI/View/List/ListStyle.swift
@@ -9,8 +9,6 @@ import OpenSwiftUICore
 
 struct AnyListStyleContext: StyleContext {}
 
-struct SidebarSectionActionStyleContext: StyleContext {}
-
 // TODO: ListStyleContext conformance and matching rules.
 struct PlainListStyleContext: StyleContext {}
 
@@ -22,6 +20,11 @@ extension StyleContext where Self == PlainListStyleContext {
 
 struct SidebarListStyleContext: StyleContext {}
 
+#if os(macOS)
+// TODO: ListStyleContext conformance and matching rules.
+struct SystemPreferencesSidebarListStyleContext: StyleContext {}
+#endif
+
 extension StyleContext where Self == SidebarListStyleContext {
     static var sidebarList: SidebarListStyleContext {
         .init()
diff --git a/Sources/OpenSwiftUI/View/List/OnDelete.swift b/Sources/OpenSwiftUI/View/List/OnDelete.swift
new file mode 100644
index 000000000..3f1ffc8f7
--- /dev/null
+++ b/Sources/OpenSwiftUI/View/List/OnDelete.swift
@@ -0,0 +1,97 @@
+//
+//  OnDelete.swift
+//  OpenSwiftUI
+//
+//  Audited for 6.5.4
+//  Status: Complete
+
+public import Foundation
+public import OpenSwiftUICore
+
+@available(OpenSwiftUI_v1_0, *)
+@usableFromInline
+struct OnDeleteTraitKey: _ViewTraitKey {
+    @inlinable
+    static var defaultValue: ((IndexSet) -> Void)? { nil }
+
+    @usableFromInline
+    typealias Value = ((IndexSet) -> Void)?
+}
+
+@available(*, unavailable)
+extension OnDeleteTraitKey: Sendable {}
+
+@available(OpenSwiftUI_v1_0, *)
+extension DynamicViewContent {
+    /// Sets the deletion action for the dynamic view. You must delete the
+    /// corresponding item within `action`, as it will be called after the
+    /// row has already been removed from the ``List``.
+    ///
+    /// - Parameter action: The action that you want OpenSwiftUI to perform when
+    ///   elements in the view are deleted. OpenSwiftUI passes a set of indices to the
+    ///   closure that's relative to the dynamic view's underlying collection of
+    ///   data.
+    ///
+    /// - Returns: A view that calls `action` when elements are deleted from the
+    ///   original view.
+    @inlinable
+    nonisolated public func onDelete(perform action: ((IndexSet) -> Void)?) -> some DynamicViewContent {
+        modifier(_TraitWritingModifier<OnDeleteTraitKey>(value: action))
+    }
+}
+
+@available(OpenSwiftUI_v1_0, *)
+@usableFromInline
+struct IsDeleteDisabledTraitKey: _ViewTraitKey {
+    @inlinable
+    static var defaultValue: Bool { false }
+
+    @usableFromInline
+    typealias Value = Bool
+}
+
+@available(*, unavailable)
+extension IsDeleteDisabledTraitKey: Sendable {}
+
+@available(OpenSwiftUI_v1_0, *)
+extension View {
+    /// Adds a condition for whether the view's view hierarchy is deletable.
+    @inlinable
+    nonisolated public func deleteDisabled(_ isDisabled: Bool) -> some View {
+        _trait(IsDeleteDisabledTraitKey.self, isDisabled)
+    }
+}
+
+struct OnDeleteDefaultTraitKey: _ViewTraitKey {
+    static var defaultValue: ((IndexSet) -> Void)? { nil }
+}
+
+struct DeleteInteraction {
+    var contentID: Int
+    var indexSet: IndexSet
+    var onDelete: ((IndexSet) -> Void)?
+
+    func delete() {
+        guard let onDelete else {
+            preconditionFailure("Attempting to delete row (indices: \(indexSet) with no associated delete action.")
+        }
+        Update.enqueueAction(reason: nil) {
+            onDelete(indexSet)
+        }
+    }
+}
+
+extension ViewTraitCollection {
+    var deleteInteraction: DeleteInteraction? {
+        guard let offset = self[DynamicViewContentOffsetTraitKey.self],
+              let contentID = self[DynamicViewContentIDTraitKey.self],
+              let onDelete = self[OnDeleteTraitKey.self] ?? self[OnDeleteDefaultTraitKey.self] else {
+            return nil
+        }
+        return DeleteInteraction(
+            contentID: contentID,
+            indexSet: IndexSet(integer: offset),
+            onDelete: self[IsDeleteDisabledTraitKey.self] ? nil : onDelete
+        )
+    }
+}
diff --git a/Sources/OpenSwiftUI/View/List/OnMove.swift b/Sources/OpenSwiftUI/View/List/OnMove.swift
new file mode 100644
index 000000000..f86f7fdc1
--- /dev/null
+++ b/Sources/OpenSwiftUI/View/List/OnMove.swift
@@ -0,0 +1,135 @@
+//
+//  OnMove.swift
+//  OpenSwiftUI
+//
+//  Audited for 6.5.4
+//  Status: Complete
+
+public import Foundation
+public import OpenSwiftUICore
+
+@available(OpenSwiftUI_v1_0, *)
+@usableFromInline
+struct OnMoveTraitKey: _ViewTraitKey {
+    @inlinable
+    static var defaultValue: ((IndexSet, Int) -> Void)? { nil }
+
+    @usableFromInline
+    typealias Value = ((IndexSet, Int) -> Void)?
+}
+
+@available(*, unavailable)
+extension OnMoveTraitKey: Sendable {}
+
+@available(OpenSwiftUI_v3_0, *)
+@available(macOS, unavailable)
+@available(watchOS, unavailable)
+@available(tvOS, unavailable)
+@usableFromInline
+struct OnMoveClipBackgroundTraitKey: _ViewTraitKey {
+    @inlinable
+    static var defaultValue: Bool { false }
+
+    @usableFromInline
+    typealias Value = Bool
+}
+
+@available(*, unavailable)
+extension OnMoveClipBackgroundTraitKey: Sendable {}
+
+@available(OpenSwiftUI_v1_0, *)
+extension DynamicViewContent {
+    /// Sets the move action for the dynamic view.
+    ///
+    /// - Parameters:
+    ///   - action: A closure that OpenSwiftUI invokes when elements in the dynamic
+    ///     view are moved. The closure takes two arguments that represent the
+    ///     offset relative to the dynamic view's underlying collection of data.
+    ///     Pass `nil` to disable the ability to move items.
+    ///
+    /// - Returns: A view that calls `action` when elements are moved within the
+    ///   original view.
+    @inlinable
+    nonisolated public func onMove(perform action: ((IndexSet, Int) -> Void)?) -> some DynamicViewContent {
+        modifier(_TraitWritingModifier<OnMoveTraitKey>(value: action))
+    }
+}
+
+@_spi(Private)
+@available(OpenSwiftUI_v3_0, *)
+@available(macOS, unavailable)
+@available(watchOS, unavailable)
+@available(tvOS, unavailable)
+extension DynamicViewContent {
+    /// Sets the move action and whether to clip its background.
+    ///
+    /// - Parameters:
+    ///   - clipBackground: Whether to clip the background during a move.
+    ///   - action: The action to perform when elements move, or `nil` to disable
+    ///     moving.
+    /// - Returns: A view with the move action and background clipping setting.
+    @inlinable
+    nonisolated public func onMove(
+        clipBackground: Bool,
+        perform action: ((IndexSet, Int) -> Void)?
+    ) -> some DynamicViewContent {
+        modifier(_TraitWritingModifier<OnMoveTraitKey>(value: action))
+            .modifier(_TraitWritingModifier<OnMoveClipBackgroundTraitKey>(value: clipBackground))
+    }
+}
+
+@available(OpenSwiftUI_v1_0, *)
+@usableFromInline
+struct IsMoveDisabledTraitKey: _ViewTraitKey {
+    @inlinable
+    static var defaultValue: Bool { false }
+
+    @usableFromInline
+    typealias Value = Bool
+}
+
+@available(*, unavailable)
+extension IsMoveDisabledTraitKey: Sendable {}
+
+@available(OpenSwiftUI_v1_0, *)
+extension View {
+    /// Adds a condition for whether the view's view hierarchy is movable.
+    @inlinable
+    nonisolated public func moveDisabled(_ isDisabled: Bool) -> some View {
+        _trait(IsMoveDisabledTraitKey.self, isDisabled)
+    }
+}
+
+struct OnMoveDefaultTraitKey: _ViewTraitKey {
+    static var defaultValue: ((IndexSet, Int) -> Void)? { nil }
+}
+
+struct MoveInteraction: CustomStringConvertible {
+    var onMove: ((IndexSet, Int) -> Void)?
+    var clipBackground: Bool
+    var sourceOffsets: IndexSet
+    var contentID: Int
+
+    func move(to destination: Int) {
+        guard let onMove else {
+            preconditionFailure("Attempting to move (\(sourceOffsets) → \(destination)) with no associated move action.")
+        }
+        let destination = sourceOffsets.integerLessThan(destination) == nil ? destination : destination &+ 1
+        Update.enqueueAction(reason: nil) {
+            onMove(sourceOffsets, destination)
+        }
+    }
+
+    var description: String {
+        "MoveInteraction(source: \(sourceOffsets), contentID: \(contentID))"
+    }
+}
+
+extension ViewTraitCollection {
+    var onMove: ((IndexSet, Int) -> Void)? {
+        guard !self[IsMoveDisabledTraitKey.self] else {
+            return nil
+        }
+        return self[OnMoveTraitKey.self] ?? self[OnMoveDefaultTraitKey.self]
+    }
+}
diff --git a/Sources/OpenSwiftUI/View/PubliclyPrimitiveView.swift b/Sources/OpenSwiftUI/View/PubliclyPrimitiveView.swift
new file mode 100644
index 000000000..2a1c1c098
--- /dev/null
+++ b/Sources/OpenSwiftUI/View/PubliclyPrimitiveView.swift
@@ -0,0 +1,69 @@
+//
+//  PubliclyPrimitiveView.swift
+//  OpenSwiftUI
+//
+//  Audited for 6.5.4
+//  Status: Complete
+//  ID: 47701A835A1B253AFF3923CF965CEFD6 (SwiftUI)
+
+import OpenAttributeGraphShims
+@_spi(ForOpenSwiftUIOnly)
+import OpenSwiftUICore
+
+// MARK: - PubliclyPrimitiveView
+
+protocol PubliclyPrimitiveView: PrimitiveView {
+    associatedtype InternalBody: View
+
+    @MainActor
+    @preconcurrency
+    var internalBody: InternalBody { get }
+}
+
+extension PubliclyPrimitiveView {
+    nonisolated public static func _makeView(
+        view: _GraphValue<Self>,
+        inputs: _ViewInputs
+    ) -> _ViewOutputs {
+        defaultMakeView(view: view, inputs: inputs)
+    }
+
+    nonisolated static func defaultMakeView(
+        view: _GraphValue<Self>,
+        inputs: _ViewInputs
+    ) -> _ViewOutputs {
+        InternalBody._makeView(view: .init(MakeBody(view: view.value)), inputs: inputs)
+    }
+
+    nonisolated public static func _makeViewList(
+        view: _GraphValue<Self>,
+        inputs: _ViewListInputs
+    ) -> _ViewListOutputs {
+        defaultMakeViewList(view: view, inputs: inputs)
+    }
+
+    nonisolated static func defaultMakeViewList(
+        view: _GraphValue<Self>,
+        inputs: _ViewListInputs
+    ) -> _ViewListOutputs {
+        InternalBody._makeViewList(view: .init(MakeBody(view: view.value)), inputs: inputs)
+    }
+
+    nonisolated public static func _viewListCount(inputs: _ViewListCountInputs) -> Int? {
+        defaultViewListCount(inputs: inputs)
+    }
+
+    nonisolated static func defaultViewListCount(inputs: _ViewListCountInputs) -> Int? {
+        InternalBody._viewListCount(inputs: inputs)
+    }
+}
+
+// MARK: - MakeBody
+
+private struct MakeBody<V>: Rule where V: PubliclyPrimitiveView {
+    @Attribute var view: V
+
+    var value: V.InternalBody {
+        view.internalBody
+    }
+}
diff --git a/Sources/OpenSwiftUI/View/Section/DefaultSectionStyle.swift b/Sources/OpenSwiftUI/View/Section/DefaultSectionStyle.swift
new file mode 100644
index 000000000..442d93444
--- /dev/null
+++ b/Sources/OpenSwiftUI/View/Section/DefaultSectionStyle.swift
@@ -0,0 +1,30 @@
+//
+//  DefaultSectionStyle.swift
+//  OpenSwiftUI
+//
+//  Audited for 6.5.4
+//  Status: Complete
+
+import OpenSwiftUICore
+
+struct DefaultSectionStyle: SectionStyle {
+    func makeBody(configuration: Configuration) -> some View {
+        var section = Section(
+            header: configuration.header,
+            content: configuration.content,
+            footer: configuration.footer
+        )
+        section.isExpanded = configuration.isExpanded
+        return section
+            .sectionStyle(SidebarSectionStyle(), in: SidebarListStyleContext())
+            #if os(macOS)
+            .sectionStyle(TextInputSuggestionSectionStyle(), in: TextInputSuggestionsContext())
+            .sectionStyle(SidebarSectionStyle(), in: SystemPreferencesSidebarListStyleContext())
+            #endif
+            .sectionStyle(MenuSectionStyle(), in: MenuStyleContext())
+            #if !os(macOS)
+            .sectionStyle(InlineActionsSectionStyle(), in: AnyListStyleContext())
+            #endif
+            .sectionStyle(PlainSectionStyle())
+    }
+}
diff --git a/Sources/OpenSwiftUI/View/Section/ListSectionSpacing.swift b/Sources/OpenSwiftUI/View/Section/ListSectionSpacing.swift
new file mode 100644
index 000000000..74401057d
--- /dev/null
+++ b/Sources/OpenSwiftUI/View/Section/ListSectionSpacing.swift
@@ -0,0 +1,250 @@
+//
+//  ListSectionSpacing.swift
+//  OpenSwiftUI
+//
+//  Audited for 6.5.4
+//  Status: Complete
+//  ID: 13443704EDBF17EBED429EA3EE76760A (SwiftUI)
+
+public import Foundation
+import OpenAttributeGraphShims
+public import OpenSwiftUICore
+
+// MARK: - ListSectionSpacing
+
+/// The spacing options between two adjacent sections in a list.
+@available(OpenSwiftUI_v5_0, *)
+@available(macOS, unavailable)
+@available(tvOS, unavailable)
+public struct ListSectionSpacing: Sendable {
+    private var storage: Storage
+
+    var value: CGFloat? {
+        switch storage {
+        case let .custom(spacing): spacing
+        case .default: nil
+        case .compact: 12
+        }
+    }
+
+    /// The default spacing between sections
+    public static let `default`: ListSectionSpacing = .init(storage: .default)
+
+    /// Compact spacing between sections
+    public static let compact: ListSectionSpacing = .init(storage: .compact)
+
+    /// Creates a custom spacing value.
+    ///
+    /// - Parameter spacing: the amount of spacing to use.
+    public static func custom(_ spacing: CGFloat) -> ListSectionSpacing {
+        .init(storage: .custom(spacing))
+    }
+
+    private enum Storage: Sendable {
+        case custom(CGFloat)
+        case `default`
+        case compact
+    }
+}
+
+// MARK: - View + listSectionSpacing
+
+@available(OpenSwiftUI_v5_0, *)
+@available(macOS, unavailable)
+@available(tvOS, unavailable)
+extension View {
+    /// Sets the spacing between adjacent sections in a ``List``.
+    ///
+    /// Pass `.default` for the default spacing, or use `.compact` for
+    /// a compact appearance between sections.
+    ///
+    /// The following example creates a ``List`` with compact spacing between
+    /// sections:
+    ///
+    ///     List {
+    ///         Section("Colors") {
+    ///             Text("Blue")
+    ///             Text("Red")
+    ///         }
+    ///
+    ///         Section("Shapes") {
+    ///             Text("Square")
+    ///             Text("Circle")
+    ///         }
+    ///     }
+    ///     .listSectionSpacing(.compact)
+    ///
+    /// Spacing can also be specified on an individual ``Section``, as in this
+    /// example:
+    ///
+    ///     Section("Borders") {
+    ///         Text("Dashed")
+    ///         Text("Solid")
+    ///     }
+    ///     .listSectionSpacing(.compact)
+    ///
+    /// Spacing applied on sections in the ``List`` overrides spacing applied on
+    /// the ``List`` as a whole.
+    ///
+    /// - Parameter spacing: the ``ListSectionSpacing`` to apply.
+    @inlinable
+    nonisolated public func listSectionSpacing(_ spacing: ListSectionSpacing) -> some View {
+        modifier(_TraitWritingModifier<ListSectionSpacingTraitKey>(value: spacing))
+            .environment(\.listSectionSpacing, spacing)
+    }
+
+    /// Sets the spacing between adjacent sections in a ``List`` to a custom
+    /// value.
+    ///
+    /// The following example creates a ``List`` with 5 pts of spacing between
+    /// sections:
+    ///
+    ///     List {
+    ///         Section("Colors") {
+    ///             Text("Blue")
+    ///             Text("Red")
+    ///         }
+    ///
+    ///         Section("Shapes") {
+    ///             Text("Square")
+    ///             Text("Circle")
+    ///         }
+    ///     }
+    ///     .listSectionSpacing(5.0)
+    ///
+    /// Spacing can also be specified on an individual ``Section``, as in this
+    /// example:
+    ///
+    ///     Section("Borders") {
+    ///         Text("Dashed")
+    ///         Text("Solid")
+    ///     }
+    ///     .listSectionSpacing(10.0)
+    ///
+    /// If adjacent sections have different spacing applied, each section
+    /// applies half its spacing above and below. Sections without
+    /// explicit spacing apply the spacing of their adjacent sections.
+    ///
+    ///     List {
+    ///         Section("Colors") {
+    ///             Text("Blue")
+    ///             Text("Red")
+    ///         }
+    ///
+    ///         Section("Borders") {
+    ///             Text("Dashed")
+    ///             Text("Solid")
+    ///         }
+    ///         .listSectionSpacing(10.0)
+    ///
+    ///         Section("Shapes") {
+    ///             Text("Square")
+    ///             Text("Circle")
+    ///         }
+    ///         .listSectionSpacing(100.0)
+    ///     }
+    ///
+    /// In the above example, the "Colors" and "Borders" section are separated
+    /// by 10 pts of spacing, and the "Borders" and "Shapes" section are
+    /// separated by 55 pts of spacing.
+    ///
+    /// Spacing applied on sections in the ``List`` overrides spacing applied on
+    /// the ``List`` as a whole.
+    ///
+    /// - Parameter spacing: the amount of spacing to apply.
+    @inlinable
+    nonisolated public func listSectionSpacing(_ spacing: CGFloat) -> some View {
+        listSectionSpacing(.custom(spacing))
+    }
+
+    nonisolated func listSectionSpacing(_ spacing: ListSectionSpacing?) -> some View {
+        modifier(_TraitWritingModifier<ListSectionSpacingTraitKey>(value: spacing))
+            .environment(\.listSectionSpacing, spacing)
+    }
+}
+
+// MARK: - ListSectionSpacingTraitKey
+
+@available(OpenSwiftUI_v5_0, *)
+@available(macOS, unavailable)
+@available(tvOS, unavailable)
+@usableFromInline
+struct ListSectionSpacingTraitKey: _ViewTraitKey {
+    @_alwaysEmitIntoClient
+    static var defaultValue: ListSectionSpacing? { nil }
+
+    @usableFromInline
+    typealias Value = ListSectionSpacing?
+}
+
+@available(*, unavailable)
+extension ListSectionSpacingTraitKey: Sendable {}
+
+// MARK: - UseCompactSectionSpacingTraitKey
+
+@available(OpenSwiftUI_v4_0, *)
+@usableFromInline
+struct UseCompactSectionSpacingTraitKey: _ViewTraitKey {
+    @inlinable
+    static var defaultValue: Bool { false }
+
+    @usableFromInline
+    typealias Value = Bool
+}
+
+@available(*, unavailable)
+extension UseCompactSectionSpacingTraitKey: Sendable {}
+
+// MARK: - EnvironmentValues + listSectionSpacing
+
+@available(OpenSwiftUI_v5_0, *)
+@available(macOS, unavailable)
+@available(tvOS, unavailable)
+extension EnvironmentValues {
+    @usableFromInline
+    var listSectionSpacing: ListSectionSpacing? {
+        get { self[ListSectionSpacingEnvironmentKey.self] }
+        set { self[ListSectionSpacingEnvironmentKey.self] = newValue }
+    }
+
+    var _listSectionSpacing: ListSectionSpacing? {
+        get { listSectionSpacing }
+        set { listSectionSpacing = newValue }
+    }
+}
+
+@available(OpenSwiftUI_v5_0, *)
+@available(macOS, unavailable)
+@available(tvOS, unavailable)
+private struct ListSectionSpacingEnvironmentKey: EnvironmentKey {
+    static var defaultValue: ListSectionSpacing? { nil }
+}
+
+// MARK: - GraphInputs + listSectionSpacing
+
+@available(OpenSwiftUI_v5_0, *)
+@available(macOS, unavailable)
+@available(tvOS, unavailable)
+extension _GraphInputs {
+    var listSectionSpacing: Attribute<ListSectionSpacing?> {
+        mapEnvironment(id: .listSectionSpacing) { $0.listSectionSpacing }
+    }
+}
+
+extension CachedEnvironment.ID {
+    static let listSectionSpacing: CachedEnvironment.ID = .init()
+}
+
+// MARK: - ViewTraitCollection + effectiveListSectionSpacing
+
+@available(OpenSwiftUI_v5_0, *)
+@available(macOS, unavailable)
+@available(tvOS, unavailable)
+extension ViewTraitCollection {
+    var effectiveListSectionSpacing: ListSectionSpacing? {
+        if let spacing = self[ListSectionSpacingTraitKey.self] {
+            return spacing
+        }
+        return self[UseCompactSectionSpacingTraitKey.self] ? .compact : nil
+    }
+}
diff --git a/Sources/OpenSwiftUI/View/Section/MenuSectionStyle.swift b/Sources/OpenSwiftUI/View/Section/MenuSectionStyle.swift
new file mode 100644
index 000000000..6181b40c9
--- /dev/null
+++ b/Sources/OpenSwiftUI/View/Section/MenuSectionStyle.swift
@@ -0,0 +1,15 @@
+//
+//  MenuSectionStyle.swift
+//  OpenSwiftUI
+//
+//  Audited for 6.5.4
+//  Status: WIP
+
+import OpenSwiftUICore
+
+struct MenuSectionStyle: SectionStyle {
+    func makeBody(configuration: Configuration) -> some View {
+        _openSwiftUIUnimplementedWarning()
+        return EmptyView()
+    }
+}
diff --git a/Sources/OpenSwiftUI/View/Section/PlainSectionStyle.swift b/Sources/OpenSwiftUI/View/Section/PlainSectionStyle.swift
new file mode 100644
index 000000000..04e6847d3
--- /dev/null
+++ b/Sources/OpenSwiftUI/View/Section/PlainSectionStyle.swift
@@ -0,0 +1,78 @@
+//
+//  PlainSectionStyle.swift
+//  OpenSwiftUI
+//
+//  Audited for 6.5.4
+//  Status: Complete
+//  ID: 4F6C9EDF4B4BD8C3129AFB2C853C1F78 (SwiftUI)
+
+import OpenAttributeGraphShims
+@_spi(ForOpenSwiftUIOnly)
+import OpenSwiftUICore
+
+// MARK: - SectionContainer
+
+private struct SectionContainer: _VariadicView.MultiViewRoot {
+    var parent: SectionStyleConfiguration.Header
+    var footer: SectionStyleConfiguration.Footer
+
+    nonisolated static func _makeViewList(
+        root: _GraphValue<Self>,
+        inputs: _ViewListInputs,
+        body: @escaping (_Graph, _ViewListInputs) -> _ViewListOutputs
+    ) -> _ViewListOutputs {
+        .groupViewList(
+            parent: root[offset: { .of(&$0.parent) }],
+            footer: root[offset: { .of(&$0.footer) }].value,
+            inputs: inputs,
+            body: body
+        )
+    }
+}
+
+// MARK: - PlainSectionStyle
+
+struct PlainSectionStyle: SectionStyle {
+    func makeBody(configuration: Configuration) -> some View {
+        StyledView(configuration: configuration)
+    }
+}
+
+// MARK: - StyledView
+
+private struct StyledView: PrimitiveView, MultiView {
+    var configuration: SectionStyleConfiguration
+
+    nonisolated static func _makeViewList(
+        view: _GraphValue<Self>,
+        inputs: _ViewListInputs
+    ) -> _ViewListOutputs {
+        SectionBody.Value._makeViewList(
+            view: .init(SectionBody(view: view.value)),
+            inputs: inputs
+        )
+    }
+
+    nonisolated static func _viewListCount(inputs: _ViewListCountInputs) -> Int? {
+        _ViewListOutputs.groupViewListCount(
+            inputs: inputs,
+            contentType: _ConditionalContent<SectionStyleConfiguration.RawContent, EmptyView>.self,
+            headerType: SectionStyleConfiguration.Header.self,
+            footerType: SectionStyleConfiguration.Footer.self
+        )
+    }
+}
+
+// MARK: - SectionBody
+
+private struct SectionBody: Rule {
+    @Attribute var view: StyledView
+
+    var value: some View {
+        _VariadicView.Tree(
+            SectionContainer(parent: view.configuration.header, footer: view.configuration.footer)
+        ) {
+            view.configuration.content
+        }
+    }
+}
diff --git a/Sources/OpenSwiftUI/View/Section/Section.swift b/Sources/OpenSwiftUI/View/Section/Section.swift
new file mode 100644
index 000000000..853b4eb40
--- /dev/null
+++ b/Sources/OpenSwiftUI/View/Section/Section.swift
@@ -0,0 +1,292 @@
+//
+//  Section.swift
+//  OpenSwiftUI
+//
+//  Audited for 6.5.4
+//  Status: Complete
+//  ID: 323999C1FFD4730F4D14ABD69CA73C8C (SwiftUI)
+
+public import OpenSwiftUICore
+
+// MARK: - Section
+
+/// A container view that you can use to add hierarchy within certain views.
+///
+/// Use `Section` instances in views like ``List``, ``Picker``, and
+/// ``Form`` to organize content into separate sections. Each section has
+/// custom content that you provide on a per-instance basis. You can also
+/// provide headers and footers for each section.
+///
+/// ### Collapsible sections
+///
+/// Create sections that expand and collapse by using an initializer that
+/// accepts an `isExpanded` binding. A collapsible section in a ``List`` that
+/// uses the ``ListStyle/sidebar`` style shows a disclosure indicator next to
+/// the section's header. Tapping on the disclosure indicator toggles the
+/// appearance of the section's content.
+///
+/// > Note: Not all contexts provide a default control to trigger collapse or
+///   expansion.
+@available(OpenSwiftUI_v1_0, *)
+public struct Section<Parent, Content, Footer> {
+    var header: Parent
+    var content: Content
+    var footer: Footer
+    var isExpanded: Binding<Bool>?
+
+    init(header: Parent, content: Content, footer: Footer) {
+        self.header = header
+        self.content = content
+        self.footer = footer
+        isExpanded = nil
+    }
+}
+
+@available(*, unavailable)
+extension Section: Sendable {}
+
+@available(OpenSwiftUI_v1_0, *)
+extension Section: View, PrimitiveView, PubliclyPrimitiveView where Parent: View, Content: View, Footer: View {
+    public typealias Body = Never
+
+    var internalBody: some View {
+        ResolvedSectionStyle(configuration: .init(isExpanded: isExpanded))
+            .viewAlias(SectionStyleConfiguration.Header.self) {
+                header.accessibilityConfiguration(
+                    AccessibilityTraitsModifier(traits: .init(trait: .isHeader))
+                )
+            }
+            .viewAlias(SectionStyleConfiguration.Footer.self) {
+                footer
+            }
+            .viewAlias(SectionStyleConfiguration.RawContent.self) {
+                content._trait(SectionActionsTraitKey.self, nil)
+            }
+    }
+
+    @available(OpenSwiftUI_v2_0, *)
+    nonisolated public static func _viewListCount(inputs: _ViewListCountInputs) -> Int? {
+        defaultViewListCount(inputs: inputs)
+    }
+}
+
+@available(OpenSwiftUI_v1_0, *)
+extension Section where Parent: View, Content: View, Footer: View {
+    /// Creates a section with a header, footer, and the provided section
+    /// content.
+    ///
+    /// - Parameters:
+    ///   - content: The section's content.
+    ///   - header: A view to use as the section's header.
+    ///   - footer: A view to use as the section's footer.
+    @_alwaysEmitIntoClient
+    public init(
+        @ViewBuilder content: () -> Content,
+        @ViewBuilder header: () -> Parent,
+        @ViewBuilder footer: () -> Footer
+    ) {
+        self.init(header: header(), footer: footer(), content: content)
+    }
+}
+
+@available(OpenSwiftUI_v1_0, *)
+extension Section where Parent == EmptyView, Content: View, Footer: View {
+    /// Creates a section with a footer and the provided section content.
+    /// - Parameters:
+    ///   - content: The section's content.
+    ///   - footer: A view to use as the section's footer.
+    @_alwaysEmitIntoClient
+    public init(@ViewBuilder content: () -> Content, @ViewBuilder footer: () -> Footer) {
+        self.init(footer: footer(), content: content)
+    }
+}
+
+@available(OpenSwiftUI_v1_0, *)
+extension Section where Parent: View, Content: View, Footer == EmptyView {
+    /// Creates a section with a header and the provided section content.
+    /// - Parameters:
+    ///   - content: The section's content.
+    ///   - header: A view to use as the section's header.
+    @_alwaysEmitIntoClient
+    public init(@ViewBuilder content: () -> Content, @ViewBuilder header: () -> Parent) {
+        self.init(header: header(), content: content)
+    }
+}
+
+@available(OpenSwiftUI_v1_0, *)
+extension Section where Parent == EmptyView, Content: View, Footer == EmptyView {
+    /// Creates a section with the provided section content.
+    /// - Parameters:
+    ///   - content: The section's content.
+    public init(@ViewBuilder content: () -> Content) {
+        self.init(header: EmptyView(), content: content(), footer: EmptyView())
+    }
+}
+
+@available(OpenSwiftUI_v3_0, *)
+extension Section where Parent == Text, Content: View, Footer == EmptyView {
+    /// Creates a section with the provided section content.
+    /// - Parameters:
+    ///   - titleKey: The key for the section's localized title, which describes
+    ///     the contents of the section.
+    ///   - content: The section's content.
+    public init(_ titleKey: LocalizedStringKey, @ViewBuilder content: () -> Content) {
+        self.init(header: Text(titleKey), content: content(), footer: EmptyView())
+    }
+
+    /// Creates a section with the provided section content.
+    /// - Parameters:
+    ///   - title: A string that describes the contents of the section.
+    ///   - content: The section's content.
+    @_disfavoredOverload
+    public init<S>(_ title: S, @ViewBuilder content: () -> Content) where S: StringProtocol {
+        self.init(header: Text(title), content: content(), footer: EmptyView())
+    }
+}
+
+@available(OpenSwiftUI_v5_0, *)
+extension Section where Parent == Text, Content: View, Footer == EmptyView {
+    /// Creates a section with the provided section content.
+    /// - Parameters:
+    ///   - titleKey: The key for the section's localized title, which describes
+    ///     the contents of the section.
+    ///   - isExpanded: A binding to a Boolean value that determines the section's
+    ///    expansion state (expanded or collapsed).
+    ///   - content: The section's content.
+    public init(
+        _ titleKey: LocalizedStringKey,
+        isExpanded: Binding<Bool>,
+        @ViewBuilder content: () -> Content
+    ) {
+        self.init(isExpanded: isExpanded, content: content) {
+            Text(titleKey)
+        }
+    }
+
+    /// Creates a section with the provided section content.
+    /// - Parameters:
+    ///   - title: A string that describes the contents of the section.
+    ///   - isExpanded: A binding to a Boolean value that determines the section's
+    ///    expansion state (expanded or collapsed).
+    ///   - content: The section's content.
+    @_disfavoredOverload
+    public init<S>(
+        _ title: S,
+        isExpanded: Binding<Bool>,
+        @ViewBuilder content: () -> Content
+    ) where S: StringProtocol {
+        self.init(isExpanded: isExpanded, content: content) {
+            Text(title)
+        }
+    }
+}
+
+@_spi(Private)
+@available(OpenSwiftUI_iOS_v4_0, *)
+@available(tvOS, unavailable)
+@available(watchOS, unavailable)
+extension Section where Parent: View, Content: View, Footer: View {
+    /// Sets whether a `Section` can be collapsed by the user.
+    ///
+    /// Currently this modifier only applies to sections in `.sidebar`-styled
+    /// `List` views.
+    public func collapsible(_ collapsible: Bool) -> some View {
+        environment(\.canCollapseSections, collapsible)
+    }
+}
+
+// MARK: - IsCollapsibleTraitKey
+
+@available(OpenSwiftUI_v1_0, *)
+@usableFromInline
+struct IsCollapsibleTraitKey: _ViewTraitKey {
+    @inlinable
+    static var defaultValue: Bool { true }
+}
+
+@available(*, unavailable)
+extension IsCollapsibleTraitKey: Sendable {}
+
+@available(OpenSwiftUI_v5_0, *)
+extension Section where Parent: View, Content: View, Footer == EmptyView {
+    /// Creates a section with a header, the provided section content, and a binding
+    /// representing the section's expansion state.
+    ///
+    /// - Parameters:
+    ///   - isExpanded: A binding to a Boolean value that determines the section's
+    ///    expansion state (expanded or collapsed).
+    ///   - content: The section's content.
+    ///   - header: A view to use as the section's header.
+    public init(
+        isExpanded: Binding<Bool>,
+        @ViewBuilder content: () -> Content,
+        @ViewBuilder header: () -> Parent
+    ) {
+        self.content = content()
+        self.header = header()
+        footer = EmptyView()
+        self.isExpanded = isExpanded
+    }
+}
+
+@available(OpenSwiftUI_v1_0, *)
+extension Section where Parent: View, Content: View, Footer: View {
+    /// Creates a section with a header, footer, and the provided section content.
+    /// - Parameters:
+    ///   - header: A view to use as the section's header.
+    ///   - footer: A view to use as the section's footer.
+    ///   - content: The section's content.
+    @available(iOS, deprecated: 100000.0, renamed: "Section(content:header:footer:)")
+    @available(macOS, deprecated: 100000.0, renamed: "Section(content:header:footer:)")
+    @available(tvOS, deprecated: 100000.0, renamed: "Section(content:header:footer:)")
+    @available(watchOS, deprecated: 100000.0, renamed: "Section(content:header:footer:)")
+    @available(visionOS, deprecated: 100000.0, renamed: "Section(content:header:footer:)")
+    public init(header: Parent, footer: Footer, @ViewBuilder content: () -> Content) {
+        self.init(header: header, content: content(), footer: footer)
+    }
+}
+
+@available(OpenSwiftUI_v1_0, *)
+extension Section where Parent == EmptyView, Content: View, Footer: View {
+    /// Creates a section with a footer and the provided section content.
+    /// - Parameters:
+    ///   - footer: A view to use as the section's footer.
+    ///   - content: The section's content.
+    @available(iOS, deprecated: 100000.0, renamed: "Section(content:footer:)")
+    @available(macOS, deprecated: 100000.0, renamed: "Section(content:footer:)")
+    @available(tvOS, deprecated: 100000.0, renamed: "Section(content:footer:)")
+    @available(watchOS, deprecated: 100000.0, renamed: "Section(content:footer:)")
+    @available(visionOS, deprecated: 100000.0, renamed: "Section(content:footer:)")
+    public init(footer: Footer, @ViewBuilder content: () -> Content) {
+        self.init(header: EmptyView(), content: content(), footer: footer)
+    }
+}
+
+@available(OpenSwiftUI_v1_0, *)
+extension Section where Parent: View, Content: View, Footer == EmptyView {
+    /// Creates a section with a header and the provided section content.
+    /// - Parameters:
+    ///   - header: A view to use as the section's header.
+    ///   - content: The section's content.
+    @available(iOS, deprecated: 100000.0, renamed: "Section(content:header:)")
+    @available(macOS, deprecated: 100000.0, renamed: "Section(content:header:)")
+    @available(tvOS, deprecated: 100000.0, renamed: "Section(content:header:)")
+    @available(watchOS, deprecated: 100000.0, renamed: "Section(content:header:)")
+    @available(visionOS, deprecated: 100000.0, renamed: "Section(content:header:)")
+    public init(header: Parent, @ViewBuilder content: () -> Content) {
+        self.init(header: header, content: content(), footer: EmptyView())
+    }
+}
+
+// MARK: - EnvironmentValues + canCollapseSections
+
+extension EnvironmentValues {
+    var canCollapseSections: Bool {
+        get { self[CollapsibleSectionsEnvironmentKey.self] }
+        set { self[CollapsibleSectionsEnvironmentKey.self] = newValue }
+    }
+}
+
+private struct CollapsibleSectionsEnvironmentKey: EnvironmentKey {
+    static var defaultValue: Bool { true }
+}
diff --git a/Sources/OpenSwiftUI/View/Section/SectionActions.swift b/Sources/OpenSwiftUI/View/Section/SectionActions.swift
new file mode 100644
index 000000000..e114df27d
--- /dev/null
+++ b/Sources/OpenSwiftUI/View/Section/SectionActions.swift
@@ -0,0 +1,79 @@
+//
+//  SectionActions.swift
+//  OpenSwiftUI
+//
+//  Audited for 6.5.4
+//  Status: Complete
+
+public import OpenSwiftUICore
+
+@available(OpenSwiftUI_v6_0, *)
+@available(tvOS, unavailable)
+@available(watchOS, unavailable)
+extension View {
+    /// Adds custom actions to a section.
+    ///
+    /// On iOS, the actions are displayed as items after the content
+    /// of the section. On macOS, the actions are displayed
+    /// when a user hovers over the section.
+    ///
+    /// The following example adds an 'Add' button to
+    /// the 'Categories' section.
+    ///
+    ///     List {
+    ///         Label("Home", systemImage: "house")
+    ///         Label("Alerts", systemImage: "bell")
+    ///
+    ///         Section("Categories") {
+    ///             Label("Climate", systemImage: "fan")
+    ///             Label("Lights", systemImage: "lightbulb")
+    ///         }
+    ///         .sectionActions {
+    ///             Button("Add Category", systemImage: "plus") { }
+    ///         }
+    ///     }
+    ///
+    nonisolated public func sectionActions<Content>(@ViewBuilder content: () -> Content) -> some View where Content: View {
+        let actions = content()
+        return viewAlias(SectionStyleConfiguration.Actions.self) {
+            actions
+        }
+        ._trait(SectionActionsTraitKey.self, AnyView(actions))
+    }
+}
+
+struct SectionActionsTraitKey: _ViewTraitKey {
+    static var defaultValue: AnyView? { nil }
+}
+
+struct SidebarSectionActionButtonStyle: PrimitiveButtonStyle {
+    func makeBody(configuration: Configuration) -> some View {
+        Button(configuration)
+            #if os(macOS)
+            .buttonStyle(SidebarSectionActionButtonStyle_Mac())
+            #else
+            .buttonStyle(PlatformItemListButtonStyle())
+            #endif
+    }
+}
+
+struct SidebarSectionActionStyleContext: StyleContext {}
+
+struct InlineActionsSectionStyle: SectionStyle {
+    func makeBody(configuration: Configuration) -> some View {
+        Section {
+            configuration.content
+                .sectionStyle(DefaultSectionStyle())
+            configuration.actions
+                .moveDisabled(true)
+                .deleteDisabled(true)
+        } header: {
+            configuration.header
+                .sectionStyle(DefaultSectionStyle())
+        } footer: {
+            configuration.footer
+                .sectionStyle(DefaultSectionStyle())
+        }
+        .sectionStyle(PlainSectionStyle())
+    }
+}
diff --git a/Sources/OpenSwiftUI/View/Section/SectionStyle.swift b/Sources/OpenSwiftUI/View/Section/SectionStyle.swift
new file mode 100644
index 000000000..7a5b49b53
--- /dev/null
+++ b/Sources/OpenSwiftUI/View/Section/SectionStyle.swift
@@ -0,0 +1,76 @@
+//
+//  SectionStyle.swift
+//  OpenSwiftUI
+//
+//  Audited for 6.5.4
+//  Status: Complete
+
+import OpenSwiftUICore
+
+// MARK: - SectionStyle
+
+protocol SectionStyle {
+    associatedtype Body: View
+
+    @ViewBuilder
+    func makeBody(configuration: Configuration) -> Body
+
+    typealias Configuration = SectionStyleConfiguration
+}
+
+extension View {
+    nonisolated func sectionStyle<S>(_ style: S) -> some View where S: SectionStyle {
+        modifier(SectionStyleModifier(style: style))
+    }
+
+    nonisolated func sectionStyle<S, C>(_ style: S, in context: C) -> some View where S: SectionStyle, C: StyleContext {
+        modifier(SectionStyleModifier(style: style).requiring(C.self))
+    }
+}
+
+// MARK: - SectionStyleConfiguration
+
+struct SectionStyleConfiguration {
+    struct Header: ViewAlias {}
+    struct Footer: ViewAlias {}
+    struct Actions: ViewAlias {}
+    struct RawContent: ViewAlias {}
+
+    let header: Header = .init()
+    let footer: Footer = .init()
+    var actions: Actions = .init()
+    let rawContent: RawContent = .init()
+    var isExpanded: Binding<Bool>?
+
+    @ViewBuilder
+    var content: some View {
+        if isExpanded?.wrappedValue ?? true {
+            rawContent
+        }
+    }
+}
+
+// MARK: - ResolvedSectionStyle
+
+struct ResolvedSectionStyle: StyleableView {
+    var configuration: SectionStyleConfiguration
+
+    static var defaultStyleModifier: SectionStyleModifier<DefaultSectionStyle> {
+        .init(style: DefaultSectionStyle())
+    }
+}
+
+// MARK: - SectionStyleModifier
+
+struct SectionStyleModifier<S>: StyleModifier where S: SectionStyle {
+    var style: S
+
+    init(style: S) {
+        self.style = style
+    }
+
+    func styleBody(configuration: SectionStyleConfiguration) -> some View {
+        style.makeBody(configuration: configuration)
+            ._trait(IsExpandedTraitKey.self, configuration.isExpanded)
+    }
+}
diff --git a/Sources/OpenSwiftUI/View/Section/SectionedIdentifierAccumulator.swift b/Sources/OpenSwiftUI/View/Section/SectionedIdentifierAccumulator.swift
new file mode 100644
index 000000000..b93c54eb1
--- /dev/null
+++ b/Sources/OpenSwiftUI/View/Section/SectionedIdentifierAccumulator.swift
@@ -0,0 +1,52 @@
+//
+//  SectionedIdentifierAccumulator.swift
+//  OpenSwiftUI
+//
+//  Audited for 6.5.4
+//  Status: Complete
+
+@_spi(ForOpenSwiftUIOnly)
+import OpenSwiftUICore
+
+struct SectionedIdentifierAccumulator: ViewListVisitor {
+    let needsIDs: Bool
+    var sections: [Sections.Item] = []
+    var sectionsWithFooters: Set<Int>?
+    var ids: [ViewList.ID] = []
+    var hasExplicitSections: Bool = false
+    var compactSections: Set<Int> = []
+    var inImplicitSection: Bool = false
+    var viewCount: Int = 0
+
+    mutating func visit(view: ViewList.View, traits: ViewTraitCollection) -> Bool {
+        if traits.groupDepth == 0 {
+            if traits.isSectioned {
+                hasExplicitSections = true
+                inImplicitSection = false
+                sections.append(Sections.Item(
+                    offset: viewCount,
+                    implicit: false,
+                    hasHeader: !traits.isEmptyView
+                ))
+            } else if !inImplicitSection {
+                inImplicitSection = true
+                sections.append(Sections.Item(
+                    offset: viewCount,
+                    implicit: true,
+                    hasHeader: false
+                ))
+            }
+            if traits[UseCompactSectionSpacingTraitKey.self] {
+                compactSections.insert(sections.count - 1)
+            }
+        }
+        if sectionsWithFooters != nil, traits.isSectionFooter {
+            sectionsWithFooters?.insert(sections.count - 1)
+        }
+        if needsIDs {
+            ids.append(view.elementID)
+        }
+        viewCount &+= 1
+        return true
+    }
+}
diff --git a/Sources/OpenSwiftUI/View/Section/Sections.swift b/Sources/OpenSwiftUI/View/Section/Sections.swift
new file mode 100644
index 000000000..b646aaa35
--- /dev/null
+++ b/Sources/OpenSwiftUI/View/Section/Sections.swift
@@ -0,0 +1,126 @@
+//
+//  Sections.swift
+//  OpenSwiftUI
+//
+//  Audited for 6.5.4
+//  Status: Complete
+
+import Foundation
+@_spi(ForOpenSwiftUIOnly)
+import OpenSwiftUICore
+
+struct Sections {
+    let children: _VariadicView.Children
+    let items: [Item]
+    let hasExplicitSections: Bool
+    let sectionsWithFooters: Set<Int>?
+    let compactSections: Set<Int>
+    let ids: ViewList.ID.Views
+
+    struct Item {
+        var offset: Int
+        var implicit: Bool
+        var hasHeader: Bool
+    }
+
+    init(from children: _VariadicView.Children, useFooters: Bool) {
+        self.children = children
+        let ids = children.list.viewIDs
+        if let traitKeys = children.list.traitKeys,
+           !traitKeys.contains(IsSectionedTraitKey.self),
+           let ids {
+            items = ids.isEmpty ? [] : [Item(offset: 0, implicit: true, hasHeader: false)]
+            hasExplicitSections = false
+            sectionsWithFooters = nil
+            compactSections = []
+            self.ids = ids
+        } else {
+            var accumulator = SectionedIdentifierAccumulator(
+                needsIDs: ids == nil,
+                sectionsWithFooters: useFooters ? [] : nil
+            )
+            children.content.visitAll(applying: &accumulator)
+            items = accumulator.sections
+            hasExplicitSections = accumulator.hasExplicitSections
+            sectionsWithFooters = accumulator.sectionsWithFooters
+            compactSections = accumulator.compactSections
+            self.ids = ids ?? ViewList.ID._Views(accumulator.ids, isDataDependent: true)
+        }
+    }
+
+    var sectionIDs: LazyMapSequence<[Item], ViewList.ID.Canonical> {
+        if hasExplicitSections {
+            items.lazy.map { [ids] in ids[$0.offset].canonicalID }
+        } else {
+            items.lazy.map { ViewList.ID().elementID(at: $0.offset).canonicalID }
+        }
+    }
+
+    func footerOffset(forSectionAt section: Int) -> Int {
+        precondition(
+            sectionsWithFooters?.contains(section) ?? false,
+            "No footer for section \(section)"
+        )
+        return endOffset(forSectionAt: section) - 1
+    }
+
+    func rowIDs(forSectionAt section: Int) -> LazyMapSequence<Slice<ViewList.ID.Views>, ViewList.ID.Canonical> {
+        let start = rowOffset(forSectionAt: section)
+        var end = endOffset(forSectionAt: section)
+        if sectionsWithFooters?.contains(section) == true {
+            end -= 1
+        }
+        return ids[start..<end].lazy.map { $0.canonicalID }
+    }
+
+    func firstIndexPath<ID>(for id: ID) -> IndexPath? where ID: Hashable {
+        guard let offset = children.list.firstOffset(forID: id, style: .init()) else {
+            return nil
+        }
+        let section = sectionIDs.indices.lowerBound {
+            endOffset(forSectionAt: $0) < offset
+        }
+        guard section < sectionIDs.count else {
+            return nil
+        }
+        return indexPath(for: offset, section: section)
+    }
+
+    func firstIndexPath(of id: ViewList.ID.Canonical) -> IndexPath? {
+        guard let offset = children.list.firstOffset(of: id) else {
+            return nil
+        }
+        let section = sectionIDs.indices.lowerBound {
+            endOffset(forSectionAt: $0) < offset
+        }
+        return indexPath(for: offset, section: section)
+    }
+
+    private func rowOffset(forSectionAt section: Int) -> Int {
+        let item = items[section]
+        return item.offset + (hasExplicitSections && !item.implicit ? 1 : 0)
+    }
+
+    private func endOffset(forSectionAt section: Int) -> Int {
+        let next = section + 1
+        return next < items.count ? items[next].offset : ids.endIndex
+    }
+
+    private func indexPath(for offset: Int, section: Int) -> IndexPath? {
+        let relativeOffset = offset - rowOffset(forSectionAt: section)
+        let count = endOffset(forSectionAt: section) - rowOffset(forSectionAt: section)
+        var row = max(relativeOffset, 0)
+        var section = section
+        if row >= count {
+            if relativeOffset <= 0, count == 0 {
+                row = NSNotFound
+            } else if section < sectionIDs.count - 1 {
+                row -= count
+                section += 1
+            } else {
+                return nil
+            }
+        }
+        return IndexPath(indexes: [section, row])
+    }
+}
diff --git a/Sources/OpenSwiftUI/View/Section/SidebarSectionStyle.swift b/Sources/OpenSwiftUI/View/Section/SidebarSectionStyle.swift
new file mode 100644
index 000000000..8e463772a
--- /dev/null
+++ b/Sources/OpenSwiftUI/View/Section/SidebarSectionStyle.swift
@@ -0,0 +1,16 @@
+//
+//  SidebarSectionStyle.swift
+//  OpenSwiftUI
+//
+//  Audited for 6.5.4
+//  Status: WIP
+//  ID: 5121C456F2956BA1169BD97287CA96C3 (SwiftUI)
+
+import OpenSwiftUICore
+
+struct SidebarSectionStyle: SectionStyle {
+    func makeBody(configuration: Configuration) -> some View {
+        _openSwiftUIUnimplementedWarning()
+        return EmptyView()
+    }
+}
diff --git a/Sources/OpenSwiftUI/View/Section/TextInputSuggestionSectionStyle.swift b/Sources/OpenSwiftUI/View/Section/TextInputSuggestionSectionStyle.swift
new file mode 100644
index 000000000..6888aaba9
--- /dev/null
+++ b/Sources/OpenSwiftUI/View/Section/TextInputSuggestionSectionStyle.swift
@@ -0,0 +1,18 @@
+//
+//  TextInputSuggestionSectionStyle.swift
+//  OpenSwiftUI
+//
+//  Audited for 6.5.4
+//  Status: WIP
+
+import OpenSwiftUICore
+
+#if os(macOS)
+struct TextInputSuggestionSectionStyle: SectionStyle {
+    func makeBody(configuration: Configuration) -> some View {
+        // TODO: SuggestionSection and SuggestionMetrics.
+        _openSwiftUIUnimplementedWarning()
+        return EmptyView()
+    }
+}
+#endif
diff --git a/Sources/OpenSwiftUICore/View/IsExpandedTraitKey.swift b/Sources/OpenSwiftUICore/View/IsExpandedTraitKey.swift
new file mode 100644
index 000000000..cb7bcad97
--- /dev/null
+++ b/Sources/OpenSwiftUICore/View/IsExpandedTraitKey.swift
@@ -0,0 +1,16 @@
+//
+//  IsExpandedTraitKey.swift
+//  OpenSwiftUICore
+//
+//  Audited for 6.5.4
+//  Status: Complete
+
+@available(OpenSwiftUI_v4_0, *)
+@usableFromInline
+package struct IsExpandedTraitKey: _ViewTraitKey {
+    @inlinable
+    package static var defaultValue: Binding<Bool>? { nil }
+}
+
+@available(*, unavailable)
+extension IsExpandedTraitKey: Sendable {}