diff --git a/Example/OpenSwiftUIUITests/Layout/Geometry/GeometryReaderUITests.swift b/Example/OpenSwiftUIUITests/Layout/Geometry/GeometryReaderUITests.swift
index a2783e0b2..8be69e0b3 100644
--- a/Example/OpenSwiftUIUITests/Layout/Geometry/GeometryReaderUITests.swift
+++ b/Example/OpenSwiftUIUITests/Layout/Geometry/GeometryReaderUITests.swift
@@ -4,35 +4,14 @@
 
 import SnapshotTesting
 import Testing
+@testable import TestingHost
 
 @MainActor
 @Suite(.snapshots(record: .never, diffTool: diffTool))
 struct GeometryReaderUITests {
     @Test(.bug("https://github.com/OpenSwiftUIProject/OpenSwiftUI/issues/474"))
     func centerView() {
-        struct ContentView: View {
-            var body: some View {
-                GeometryReader { proxy in
-                    Color.blue
-                        .frame(
-                            width: proxy.size.width / 2,
-                            height: proxy.size.height / 2,
-                        )
-                        .frame(maxWidth: .infinity, maxHeight: .infinity)
-                        .background(Color.yellow.opacity(0.3))
-                }
-            }
-        }
-        openSwiftUIAssertSnapshot(of: ContentView())
-        #if os(iOS)
-        #if OPENSWIFTUI
-        withKnownIssue {
-            openSwiftUIAssertSnapshot(of: ContentView(), as: .image)
-        }
-        #else
-        openSwiftUIAssertSnapshot(of: ContentView(), as: .image)
-        #endif
-        #endif
+        openSwiftUIAssertSnapshot(of: GeometryReaderExample())
     }
 
     @Test
diff --git a/Example/Shared/Layout/Geometry/GeometryReaderExample.swift b/Example/Shared/Layout/Geometry/GeometryReaderExample.swift
index bba3d90af..663bc4c8f 100644
--- a/Example/Shared/Layout/Geometry/GeometryReaderExample.swift
+++ b/Example/Shared/Layout/Geometry/GeometryReaderExample.swift
@@ -8,8 +8,6 @@ import OpenSwiftUI
 import SwiftUI
 #endif
 
-// FIXME: SwiftUI yellow background will ignoreSafeArea while OpenSwiftUI will have it.
-// See #474
 struct GeometryReaderExample: View {
     var body: some View {
         GeometryReader { geometry in
diff --git a/Sources/OpenSwiftUICore/Layout/Geometry/Anchor.swift b/Sources/OpenSwiftUICore/Layout/Geometry/Anchor.swift
index 4281c3549..a457abab7 100644
--- a/Sources/OpenSwiftUICore/Layout/Geometry/Anchor.swift
+++ b/Sources/OpenSwiftUICore/Layout/Geometry/Anchor.swift
@@ -189,7 +189,9 @@ private class AnchorValueBox<T>: AnchorValueBoxBase<T.AnchorValue>, @unchecked S
     }
 
     override func convert(to transform: ViewTransform) -> T.AnchorValue {
-        _openSwiftUIUnimplementedFailure()
+        var value = value
+        value.convert(to: .global, transform: transform)
+        return value
     }
 
     override func isEqual(to other: AnchorValueBoxBase<T.AnchorValue>) -> Bool {
diff --git a/Sources/OpenSwiftUICore/Layout/Geometry/GeometryReader.swift b/Sources/OpenSwiftUICore/Layout/Geometry/GeometryReader.swift
index c77c9457e..b74d29297 100644
--- a/Sources/OpenSwiftUICore/Layout/Geometry/GeometryReader.swift
+++ b/Sources/OpenSwiftUICore/Layout/Geometry/GeometryReader.swift
@@ -3,14 +3,14 @@
 //  OpenSwiftUICore
 //
 //  Audited for 6.5.4
-//  Status: WIP
+//  Status: Complete
 //  ID: 7D6D22DF7076CCC1FC5284D8E2D1B049 (SwiftUICore)
 
 public import Foundation
 package import OpenAttributeGraphShims
 import OpenSwiftUI_SPI
 
-// MARK: - GeometryReader [WIP]
+// MARK: - GeometryReader
 
 /// A container view that defines its content as a function of its own size and
 /// coordinate space.
@@ -80,7 +80,7 @@ public struct GeometryReader<Content>: View, UnaryView, PrimitiveView where Cont
         mutating func updateValue() {
             seed &+= 1
             let proxy = GeometryProxy(
-                owner: .current!,
+                owner: attribute.identifier,
                 size: $size,
                 environment: $environment,
                 transform: $transform,
@@ -101,7 +101,7 @@ public struct GeometryReader<Content>: View, UnaryView, PrimitiveView where Cont
 @available(*, unavailable)
 extension GeometryReader: Sendable {}
 
-// MARK: - GeometryProxy [WIP]
+// MARK: - GeometryProxy
 
 /// A proxy for access to the size and coordinate space (for anchor resolution)
 /// of the container view.
@@ -169,7 +169,9 @@ public struct GeometryProxy {
 
     /// Resolves the value of an anchor to the container view.
     public subscript<T>(anchor: Anchor<T>) -> T {
-        _openSwiftUIUnimplementedFailure()
+        Update.perform {
+            placementContext.map { anchor.in($0) } ?? anchor.defaultValue
+        }
     }
 
     /// The safe area inset of the container view.
@@ -188,28 +190,41 @@ public struct GeometryProxy {
     @available(*, deprecated, message: "use overload that accepts a CoordinateSpaceProtocol instead")
     @_disfavoredOverload
     public func frame(in coordinateSpace: CoordinateSpace) -> CGRect {
-        let size = size
-        return Update.perform {
-            guard let placementContext else {
-                return .zero
-            }
-            var rect = CGRect(origin: .zero, size: size)
-            rect.convert(from: placementContext, to: coordinateSpace)
-            return rect
-        }
+        rect(CGRect(origin: .zero, size: size), in: coordinateSpace)
     }
 
     @_spi(Private)
     public func frameClippedToScrollViews(in space: CoordinateSpace) -> (frame: CGRect, exact: Bool) {
-        _openSwiftUIUnimplementedFailure()
+        Update.perform {
+            var rect = CGRect(origin: .zero, size: size)
+            guard let placementContext else {
+                return (rect, true)
+            }
+            let exact = rect.whileClippingToScrollViewsConvert(
+                to: space,
+                transform: placementContext.transform
+            )
+            return (rect, exact)
+        }
     }
 
     package func rect(_ r: CGRect, in coordinateSpace: CoordinateSpace) -> CGRect {
-        _openSwiftUIUnimplementedFailure()
+        Update.perform {
+            var rect = r
+            placementContext.map { rect.convert(from: $0, to: coordinateSpace) }
+            return rect
+        }
     }
 
     package var transform: ViewTransform {
-        _openSwiftUIUnimplementedFailure()
+        Update.perform {
+            guard let transform = _transform.attribute,
+                  let position = _position.attribute
+            else {
+                return ViewTransform()
+            }
+            return context[transform].withPosition(context[position])
+        }
     }
 
     package var environment: EnvironmentValues {
@@ -244,13 +259,13 @@ extension GeometryProxy {
     /// Returns the given coordinate space's bounds rectangle, converted to the
     /// local coordinate space.
     public func bounds(of coordinateSpace: NamedCoordinateSpace) -> CGRect? {
-        _openSwiftUIUnimplementedFailure()
+        transform.containingSizedCoordinateSpace(name: coordinateSpace.name)
     }
 
     /// Returns the container view's bounds rectangle, converted to a defined
     /// coordinate space.
     public func frame(in coordinateSpace: some CoordinateSpaceProtocol) -> CGRect {
-        _openSwiftUIUnimplementedFailure()
+        rect(CGRect(origin: .zero, size: size), in: coordinateSpace.coordinateSpace)
     }
 }
 
@@ -260,7 +275,8 @@ extension GeometryProxy {
         globalPoint: CGPoint,
         to coordinateSpace: some CoordinateSpaceProtocol,
     ) -> CGPoint {
-        _openSwiftUIUnimplementedFailure()
+        // TBA: ViewTransform
+        transform.convert(.localToSpace(coordinateSpace.coordinateSpace), point: globalPoint)
     }
 }
 
diff --git a/Sources/OpenSwiftUICore/Layout/View/ViewTransform.swift b/Sources/OpenSwiftUICore/Layout/View/ViewTransform.swift
index baf5d324b..c8a2c9d0b 100644
--- a/Sources/OpenSwiftUICore/Layout/View/ViewTransform.swift
+++ b/Sources/OpenSwiftUICore/Layout/View/ViewTransform.swift
@@ -327,7 +327,11 @@ public struct ViewTransform: Equatable, CustomStringConvertible {
     }
     
     package func containingSizedCoordinateSpace(name: CoordinateSpace.Name) -> CGRect? {
-        _openSwiftUIUnimplementedFailure()
+        var rect: CGRect?
+        forEach { item, _ in
+            item.apply(to: &rect, name: name)
+        }
+        return rect
     }
     
     public var description: String {
diff --git a/Sources/OpenSwiftUICore/Modifier/ViewModifier/BackgroundModifier.swift b/Sources/OpenSwiftUICore/Modifier/ViewModifier/BackgroundModifier.swift
index 5f4b71d3d..986daf5d8 100644
--- a/Sources/OpenSwiftUICore/Modifier/ViewModifier/BackgroundModifier.swift
+++ b/Sources/OpenSwiftUICore/Modifier/ViewModifier/BackgroundModifier.swift
@@ -1,9 +1,15 @@
 //
 //  BackgroundModifier.swift
 //  OpenSwiftUICore
-//  Status: WIP
+//
+//  Audited for 6.5.4
+//  Status: Complete
+//  ID: 4F6988968057BB8D11F78AD2EE32ACB1 (SwiftUICore)
+
+package import Foundation
+import OpenAttributeGraphShims
 
-// MARK: - BackgroundModifier [6.4.41]
+// MARK: - BackgroundModifier
 
 /// A modifier that layers a secondary view behind the primary content it
 /// modifies, while maintaining the layout characteristics of the primary view.
@@ -38,11 +44,316 @@ public struct _BackgroundModifier<Background>: ViewModifier, MultiViewModifier,
 }
 
 @available(*, unavailable)
-extension _BackgroundModifier : Sendable {}
+extension _BackgroundModifier: Sendable {}
 
-// TODO
+@available(OpenSwiftUI_v1_0, *)
+extension _BackgroundModifier: Equatable where Background: Equatable {
+    nonisolated public static func == (a: _BackgroundModifier<Background>, b: _BackgroundModifier<Background>) -> Bool {
+        a.background == b.background && a.alignment == b.alignment
+    }
+}
 
-// MARK: - View + Background [6.4.41] [WIP]
+// MARK: - BackgroundStyleModifier
+
+@available(OpenSwiftUI_v3_0, *)
+@frozen
+public struct _BackgroundStyleModifier<Style>: ViewModifier, MultiViewModifier, PrimitiveViewModifier, ShapeStyledLeafView where Style: ShapeStyle {
+    public var style: Style
+
+    public var ignoresSafeAreaEdges: Edge.Set
+
+    @inlinable
+    public init(style: Style, ignoresSafeAreaEdges: Edge.Set) {
+        self.style = style
+        self.ignoresSafeAreaEdges = ignoresSafeAreaEdges
+    }
+
+    nonisolated public static func _makeView(
+        modifier: _GraphValue<Self>,
+        inputs: _ViewInputs,
+        body: @escaping (_Graph, _ViewInputs) -> _ViewOutputs
+    ) -> _ViewOutputs {
+        makeShapeView(
+            modifier: modifier,
+            inputs: inputs,
+            shapeIsBackground: true,
+            body: body
+        )
+    }
+
+    nonisolated package static func makeShapeView(
+        modifier: _GraphValue<Self>,
+        inputs: _ViewInputs,
+        shapeIsBackground: Bool,
+        body: @escaping (_Graph, _ViewInputs) -> _ViewOutputs
+    ) -> _ViewOutputs {
+        let backgroundInfo = Attribute(BackgroundInfo(
+            modifier: modifier.value,
+            environment: inputs.environment,
+            size: inputs.size,
+            position: inputs.position,
+            transform: inputs.transform,
+            safeAreaInsets: inputs.safeAreaInsets
+        ))
+        var secondaryInputs = inputs
+        secondaryInputs.implicitRootType = _ZStackLayout.self
+        secondaryInputs.position = backgroundInfo[offset: { .of(&$0.frame.origin) }]
+        secondaryInputs.size = backgroundInfo[offset: { .of(&$0.frame.size) }]
+        let styles = Attribute(ShapeStyleResolver(
+            style: .init(backgroundInfo[offset: { .of(&$0.style) }]),
+            mode: .init(),
+            environment: inputs.environment,
+            role: .fill,
+            animationsDisabled: inputs.base.animationsDisabled,
+            helper: .init(
+                phase: inputs.viewPhase,
+                time: inputs.time,
+                transaction: inputs.transaction
+            )
+        ))
+        styles.flags = .transactional
+        var primaryInputs = inputs
+        if shapeIsBackground {
+            primaryInputs.applyBackgroundStyle(
+                value: modifier.value,
+                offset: .offset { .of(&$0.style) }
+            )
+        }
+        let primaryOutputs = body(_Graph(), primaryInputs)
+        let secondaryOutputs = makeLeafView(
+            view: modifier,
+            inputs: secondaryInputs,
+            styles: styles
+        )
+        var visitor = PairwisePreferenceCombinerVisitor(
+            outputs: shapeIsBackground ? (secondaryOutputs, primaryOutputs) : (primaryOutputs, secondaryOutputs)
+        )
+        for key in primaryInputs.preferences.keys {
+            key.visitKey(&visitor)
+        }
+        var result = visitor.result
+        result.layoutComputer = primaryOutputs.layoutComputer
+        return result
+    }
+
+    package func shape(in size: CGSize) -> FramedShape {
+        let rect = CGRect(origin: .zero, size: size)
+        return (
+            shape: .path(ImplicitContainerShape().path(in: rect), FillStyle()),
+            frame: rect
+        )
+    }
+
+    private struct BackgroundInfo: Rule, AsyncAttribute {
+        @Attribute var modifier: _BackgroundStyleModifier<Style>
+        @Attribute var environment: EnvironmentValues
+        @Attribute var size: ViewSize
+        @Attribute var position: ViewOrigin
+        @Attribute var transform: ViewTransform
+        @OptionalAttribute var safeAreaInsets: SafeAreaInsets?
+
+        var value: Value {
+            var result = Value(
+                frame: ViewFrame(origin: position, size: size),
+                style: _AnchoredShapeStyle(
+                    style: modifier.style,
+                    bounds: CGRect(origin: .zero, size: size.value)
+                )
+            )
+            let edges = modifier.ignoresSafeAreaEdges
+            if !edges.isEmpty {
+                let context = AnyRuleContext(context)
+                var insets = EdgeInsets.zero
+                if let safeAreaInsetsAttribute = $safeAreaInsets {
+                    insets = context[safeAreaInsetsAttribute].resolve(
+                        regions: .background,
+                        in: _PositionAwarePlacementContext(
+                            context: context,
+                            size: _size,
+                            environment: _environment,
+                            transform: _transform,
+                            position: _position,
+                            safeAreaInsets: _safeAreaInsets
+                        )
+                    ).in(edges)
+                }
+                let offset = insets.originOffset
+                result.style.bounds.origin += offset
+                result.frame.origin -= offset
+                result.frame.size.value = result.frame.size.value.outset(by: insets)
+            }
+            return result
+        }
+
+        struct Value {
+            var frame: ViewFrame
+            var style: _AnchoredShapeStyle<Style>
+
+            init(frame: ViewFrame, style: _AnchoredShapeStyle<Style>) {
+                self.frame = frame
+                self.style = style
+            }
+        }
+    }
+
+    public typealias Body = Never
+}
+
+@available(*, unavailable)
+extension _BackgroundStyleModifier: Sendable {}
+
+// MARK: - BackgroundShapeModifier
+
+@available(OpenSwiftUI_v3_0, *)
+@frozen
+public struct _BackgroundShapeModifier<Style, Bounds>: ViewModifier, MultiViewModifier, PrimitiveViewModifier, ShapeStyledLeafView where Style: ShapeStyle, Bounds: Shape {
+    public var style: Style
+
+    public var shape: Bounds
+
+    public var fillStyle: FillStyle
+
+    @inlinable
+    public init(style: Style, shape: Bounds, fillStyle: FillStyle) {
+        self.style = style
+        self.shape = shape
+        self.fillStyle = fillStyle
+    }
+
+    nonisolated public static func _makeView(
+        modifier: _GraphValue<Self>,
+        inputs: _ViewInputs,
+        body: @escaping (_Graph, _ViewInputs) -> _ViewOutputs
+    ) -> _ViewOutputs {
+        makeShapeView(
+            modifier: modifier,
+            inputs: inputs,
+            shapeIsBackground: true,
+            body: body
+        )
+    }
+
+    nonisolated static func makeShapeView(
+        modifier: _GraphValue<Self>,
+        inputs: _ViewInputs,
+        shapeIsBackground: Bool,
+        body: @escaping (_Graph, _ViewInputs) -> _ViewOutputs,
+        modifyPrimaryInputs: (inout _ViewInputs, Attribute<Bounds>) -> Void = { _, _ in }
+    ) -> _ViewOutputs {
+        var secondaryInputs = inputs
+        secondaryInputs.implicitRootType = _ZStackLayout.self
+        let styles = Attribute(ShapeStyleResolver(
+            style: .init(modifier[offset: { .of(&$0.style) }].value),
+            mode: .init(),
+            environment: inputs.environment,
+            role: Bounds.role,
+            animationsDisabled: inputs.base.animationsDisabled,
+            helper: .init(
+                phase: inputs.viewPhase,
+                time: inputs.time,
+                transaction: inputs.transaction
+            )
+        ))
+        styles.flags = .transactional
+        let secondaryOutputs: _ViewOutputs
+        let shape: Attribute<Bounds>
+        if MemoryLayout<Bounds.AnimatableData>.size == 0 {
+            secondaryOutputs = makeLeafView(
+                view: modifier,
+                inputs: secondaryInputs,
+                styles: styles
+            )
+            shape = modifier[offset: { .of(&$0.shape) }].value
+        } else {
+            shape = Bounds.makeAnimatable(
+                value: modifier[offset: { .of(&$0.shape) }],
+                inputs: inputs.base
+            )
+            let fillStyle = modifier[offset: { .of(&$0.fillStyle) }].value
+            let animatedShape = _GraphValue(AnimatedShape<Bounds>.Init(
+                shape: shape,
+                fillStyle: fillStyle
+            ))
+            secondaryOutputs = AnimatedShape<Bounds>.makeLeafView(
+                view: animatedShape,
+                inputs: secondaryInputs,
+                styles: styles
+            )
+        }
+        var primaryInputs = inputs
+        if shapeIsBackground {
+            primaryInputs.applyBackgroundStyle(
+                value: modifier.value,
+                offset: .offset { .of(&$0.style) }
+            )
+        }
+        modifyPrimaryInputs(&primaryInputs, shape)
+        let primaryOutputs = body(_Graph(), primaryInputs)
+        var visitor = PairwisePreferenceCombinerVisitor(
+            outputs: shapeIsBackground ? (secondaryOutputs, primaryOutputs) : (primaryOutputs, secondaryOutputs)
+        )
+        for key in primaryInputs.preferences.keys {
+            key.visitKey(&visitor)
+        }
+        var result = visitor.result
+        result.layoutComputer = primaryOutputs.layoutComputer
+        return result
+    }
+
+    package func shape(in size: CGSize) -> FramedShape {
+        let rect = CGRect(origin: .zero, size: size)
+        return (
+            shape: .path(shape.effectivePath(in: rect), fillStyle),
+            frame: rect
+        )
+    }
+
+    public typealias Body = Never
+}
+
+@available(*, unavailable)
+extension _BackgroundShapeModifier: Sendable {}
+
+// MARK: - InsettableBackgroundShapeModifier
+
+@available(OpenSwiftUI_v3_0, *)
+@frozen
+public struct _InsettableBackgroundShapeModifier<Style, Bounds>: ViewModifier, MultiViewModifier, PrimitiveViewModifier where Style: ShapeStyle, Bounds: InsettableShape {
+    public var style: Style
+
+    public var shape: Bounds
+
+    public var fillStyle: FillStyle
+
+    @inlinable
+    public init(style: Style, shape: Bounds, fillStyle: FillStyle) {
+        self.style = style
+        self.shape = shape
+        self.fillStyle = fillStyle
+    }
+
+    nonisolated public static func _makeView(
+        modifier: _GraphValue<Self>,
+        inputs: _ViewInputs,
+        body: @escaping (_Graph, _ViewInputs) -> _ViewOutputs
+    ) -> _ViewOutputs {
+        _BackgroundShapeModifier.makeShapeView(
+            modifier: modifier.unsafeBitCast(to: _BackgroundShapeModifier<Style, Bounds>.self),
+            inputs: inputs,
+            shapeIsBackground: true,
+            body: body
+        ) { inputs, shape in
+            inputs.setContainerShape(shape, isSystemShape: false)
+        }
+    }
+
+    public typealias Body = Never
+}
+
+@available(*, unavailable)
+extension _InsettableBackgroundShapeModifier: Sendable {}
+
+// MARK: - View + Background
 
 @available(OpenSwiftUI_v1_0, *)
 extension View {
@@ -99,7 +410,7 @@ extension View {
     /// Layers the views that you specify behind this view.
     ///
     /// Use this modifier to place one or more views behind another view.
-    /// For example, you can place a collection of stars beind a ``Text`` view:
+    /// For example, you can place a collection of stars behind a ``Text`` view:
     ///
     ///     Text("ABCDEF")
     ///         .background(alignment: .leading) { Star(color: .red) }
@@ -221,6 +532,323 @@ extension View {
     /// - Returns: A view that uses the specified content as a background.
     @inlinable
     nonisolated public func background<V>(alignment: Alignment = .center, @ViewBuilder content: () -> V) -> some View where V: View {
-          modifier(_BackgroundModifier(background: content(), alignment: alignment))
-      }
+        modifier(_BackgroundModifier(background: content(), alignment: alignment))
+    }
+
+    /// Sets the view's background to the default background style.
+    ///
+    /// This modifier behaves like ``View/background(_:ignoresSafeAreaEdges:)``,
+    /// except that it always uses the ``ShapeStyle/background`` shape style.
+    /// For example, you can add a background to a ``Label``:
+    ///
+    ///     ZStack {
+    ///         Color.teal
+    ///         Label("Flag", systemImage: "flag.fill")
+    ///             .padding()
+    ///             .background()
+    ///     }
+    ///
+    /// Without the background modifier, the teal color behind the label shows
+    /// through the label. With the modifier, the label's text and icon appear
+    /// backed by a region filled with a color that's appropriate for light
+    /// or dark appearance:
+    ///
+    /// ![A screenshot of a flag icon and the word flag inside a rectangle; the
+    /// rectangle is filled with the background color and layered on top of a
+    /// larger rectangle that's filled with the color teal.](View-background-7)
+    ///
+    /// If you want to specify a ``View`` or a stack of views as the background,
+    /// use ``View/background(alignment:content:)`` instead.
+    /// To specify a ``Shape`` or ``InsettableShape``, use
+    /// ``View/background(_:in:fillStyle:)``.
+    /// To configure the background of a presentation, like a sheet, use
+    /// ``View/presentationBackground(_:)``.
+    ///
+    /// - Parameters:
+    ///   - edges: The set of edges for which to ignore safe area insets
+    ///     when adding the background. The default value is ``Edge/Set/all``.
+    ///     Specify an empty set to respect safe area insets on all edges.
+    ///
+    /// - Returns: A view with the ``ShapeStyle/background`` shape style
+    ///   drawn behind it.
+    @inlinable
+    nonisolated public func background(ignoresSafeAreaEdges edges: Edge.Set = .all) -> some View {
+        modifier(_BackgroundStyleModifier(style: .background, ignoresSafeAreaEdges: edges))
+    }
+
+    /// Sets the view's background to a style.
+    ///
+    /// Use this modifier to place a type that conforms to the ``ShapeStyle``
+    /// protocol --- like a ``Color``, ``Material``, or
+    /// ``HierarchicalShapeStyle`` --- behind a view. For example, you can add
+    /// the ``ShapeStyle/regularMaterial`` behind a ``Label``:
+    ///
+    ///     struct FlagLabel: View {
+    ///         var body: some View {
+    ///             Label("Flag", systemImage: "flag.fill")
+    ///                 .padding()
+    ///                 .background(.regularMaterial)
+    ///         }
+    ///     }
+    ///
+    /// OpenSwiftUI anchors the style to the view's bounds. For the example above,
+    /// the background fills the entirety of the label's frame, which includes
+    /// the padding:
+    ///
+    /// ![A screenshot of a flag symbol and the word flag layered over a
+    /// gray rectangle.](View-background-5)
+    ///
+    /// OpenSwiftUI limits the background style's extent to the modified view's
+    /// container-relative shape. You can see this effect if you constrain the
+    /// `FlagLabel` view with a ``View/containerShape(_:)`` modifier:
+    ///
+    ///     FlagLabel()
+    ///         .containerShape(RoundedRectangle(cornerRadius: 16))
+    ///
+    /// The background takes on the specified container shape:
+    ///
+    /// ![A screenshot of a flag symbol and the word flag layered over a
+    /// gray rectangle with rounded corners.](View-background-6)
+    ///
+    /// By default, the background ignores safe area insets on all edges, but
+    /// you can provide a specific set of edges to ignore, or an empty set to
+    /// respect safe area insets on all edges:
+    ///
+    ///     Rectangle()
+    ///         .background(
+    ///             .regularMaterial,
+    ///             ignoresSafeAreaEdges: []) // Ignore no safe area insets.
+    ///
+    /// If you want to specify a ``View`` or a stack of views as the background,
+    /// use ``View/background(alignment:content:)`` instead.
+    /// To specify a ``Shape`` or ``InsettableShape``, use
+    /// ``View/background(_:in:fillStyle:)`` .
+    /// To configure the background of a presentation, like a sheet, use
+    /// ``View/presentationBackground(_:)``.
+    ///
+    /// - Parameters:
+    ///   - style: An instance of a type that conforms to ``ShapeStyle`` that
+    ///     OpenSwiftUI draws behind the modified view.
+    ///   - edges: The set of edges for which to ignore safe area insets
+    ///     when adding the background. The default value is ``Edge/Set/all``.
+    ///     Specify an empty set to respect safe area insets on all edges.
+    ///
+    /// - Returns: A view with the specified style drawn behind it.
+    @inlinable
+    nonisolated public func background<S>(_ style: S, ignoresSafeAreaEdges edges: Edge.Set = .all) -> some View where S: ShapeStyle {
+        modifier(_BackgroundStyleModifier(style: style, ignoresSafeAreaEdges: edges))
+    }
+
+    /// Sets the view's background to a shape filled with the
+    /// default background style.
+    ///
+    /// This modifier behaves like ``View/background(_:in:fillStyle:)``,
+    /// except that it always uses the ``ShapeStyle/background`` shape style
+    /// to fill the specified shape. For example, you can create a ``Path``
+    /// that outlines a trapezoid:
+    ///
+    ///     let trapezoid = Path { path in
+    ///         path.move(to: .zero)
+    ///         path.addLine(to: CGPoint(x: 90, y: 0))
+    ///         path.addLine(to: CGPoint(x: 80, y: 50))
+    ///         path.addLine(to: CGPoint(x: 10, y: 50))
+    ///     }
+    ///
+    /// Then you can use that shape as a background for a ``Label``:
+    ///
+    ///     ZStack {
+    ///         Color.teal
+    ///         Label("Flag", systemImage: "flag.fill")
+    ///             .padding()
+    ///             .background(in: trapezoid)
+    ///     }
+    ///
+    /// Without the background modifier, the fill color shows
+    /// through the label. With the modifier, the label's text and icon appear
+    /// backed by a shape filled with a color that's appropriate for light
+    /// or dark appearance:
+    ///
+    /// ![A screenshot of a flag icon and the word flag inside a trapezoid; the
+    /// trapezoid is filled with the background color and layered on top of
+    /// a rectangle filled with the color teal.](View-background-B)
+    ///
+    /// To create a background with other ``View`` types --- or with a stack
+    /// of views --- use ``View/background(alignment:content:)`` instead.
+    /// To add a ``ShapeStyle`` as a background, use
+    /// ``View/background(_:ignoresSafeAreaEdges:)``.
+    ///
+    /// - Parameters:
+    ///   - shape: An instance of a type that conforms to ``Shape`` that
+    ///     OpenSwiftUI draws behind the view using the ``ShapeStyle/background``
+    ///     shape style.
+    ///   - fillStyle: The ``FillStyle`` to use when drawing the shape.
+    ///     The default style uses the nonzero winding number rule and
+    ///     antialiasing.
+    ///
+    /// - Returns: A view with the specified shape drawn behind it.
+    @inlinable
+    nonisolated public func background<S>(in shape: S, fillStyle: FillStyle = FillStyle()) -> some View where S: Shape {
+        modifier(_BackgroundShapeModifier(style: .background, shape: shape, fillStyle: fillStyle))
+    }
+
+    /// Sets the view's background to a shape filled with a style.
+    ///
+    /// Use this modifier to layer a type that conforms to the ``Shape``
+    /// protocol behind a view. Specify the ``ShapeStyle`` that's used to
+    /// fill the shape. For example, you can create a ``Path`` that outlines
+    /// a trapezoid:
+    ///
+    ///     let trapezoid = Path { path in
+    ///         path.move(to: .zero)
+    ///         path.addLine(to: CGPoint(x: 90, y: 0))
+    ///         path.addLine(to: CGPoint(x: 80, y: 50))
+    ///         path.addLine(to: CGPoint(x: 10, y: 50))
+    ///     }
+    ///
+    /// Then you can use that shape as a background for a ``Label``:
+    ///
+    ///     Label("Flag", systemImage: "flag.fill")
+    ///         .padding()
+    ///         .background(.teal, in: trapezoid)
+    ///
+    /// The ``ShapeStyle/teal`` color fills the shape:
+    ///
+    /// ![A screenshot of the flag icon and the word flag inside a trapezoid;
+    /// The trapezoid is filled with the color teal.](View-background-A)
+    ///
+    /// This modifier is a convenience method for placing a single shape behind a view. To
+    /// create a background with other ``View`` types --- or with a stack
+    /// of views --- use ``View/background(alignment:content:)`` instead.
+    /// To add a ``ShapeStyle`` as a background, use
+    /// ``View/background(_:ignoresSafeAreaEdges:)``.
+    ///
+    /// - Parameters:
+    ///   - style: A ``ShapeStyle`` that OpenSwiftUI uses to the fill the shape
+    ///     that you specify.
+    ///   - shape: An instance of a type that conforms to ``Shape`` that
+    ///     OpenSwiftUI draws behind the view.
+    ///   - fillStyle: The ``FillStyle`` to use when drawing the shape.
+    ///     The default style uses the nonzero winding number rule and
+    ///     antialiasing.
+    ///
+    /// - Returns: A view with the specified shape drawn behind it.
+    @inlinable
+    nonisolated public func background<S, T>(_ style: S, in shape: T, fillStyle: FillStyle = FillStyle()) -> some View where S: ShapeStyle, T: Shape {
+        modifier(_BackgroundShapeModifier(style: style, shape: shape, fillStyle: fillStyle))
+    }
+
+    /// Sets the view's background to an insettable shape filled with the
+    /// default background style.
+    ///
+    /// This modifier behaves like ``View/background(_:in:fillStyle:)``,
+    /// except that it always uses the ``ShapeStyle/background`` shape style
+    /// to fill the specified insettable shape. For example, you can use
+    /// a ``RoundedRectangle`` as a background on a ``Label``:
+    ///
+    ///     ZStack {
+    ///         Color.teal
+    ///         Label("Flag", systemImage: "flag.fill")
+    ///             .padding()
+    ///             .background(in: RoundedRectangle(cornerRadius: 8))
+    ///     }
+    ///
+    /// Without the background modifier, the fill color shows
+    /// through the label. With the modifier, the label's text and icon appear
+    /// backed by a shape filled with a color that's appropriate for light
+    /// or dark appearance:
+    ///
+    /// ![A screenshot of a flag icon and the word flag inside a rectangle with
+    /// rounded corners; the rectangle is filled with the background color, and
+    /// is layered on top of a larger rectangle that's filled with the color
+    /// teal.](View-background-9)
+    ///
+    /// To create a background with other ``View`` types --- or with a stack
+    /// of views --- use ``View/background(alignment:content:)`` instead.
+    /// To add a ``ShapeStyle`` as a background, use
+    /// ``View/background(_:ignoresSafeAreaEdges:)``.
+    ///
+    /// - Parameters:
+    ///   - shape: An instance of a type that conforms to ``InsettableShape``
+    ///     that OpenSwiftUI draws behind the view using the
+    ///     ``ShapeStyle/background`` shape style.
+    ///   - fillStyle: The ``FillStyle`` to use when drawing the shape.
+    ///     The default style uses the nonzero winding number rule and
+    ///     antialiasing.
+    ///
+    /// - Returns: A view with the specified insettable shape drawn behind it.
+    @inlinable
+    nonisolated public func background<S>(in shape: S, fillStyle: FillStyle = FillStyle()) -> some View where S: InsettableShape {
+        modifier(_InsettableBackgroundShapeModifier(style: .background, shape: shape, fillStyle: fillStyle))
+    }
+
+    /// Sets the view's background to an insettable shape filled with a style.
+    ///
+    /// Use this modifier to layer a type that conforms to the
+    /// ``InsettableShape`` protocol --- like a ``Rectangle``, ``Circle``, or
+    /// ``Capsule`` --- behind a view. Specify the ``ShapeStyle`` that's used to
+    /// fill the shape. For example, you can place a ``RoundedRectangle``
+    /// behind a ``Label``:
+    ///
+    ///     Label("Flag", systemImage: "flag.fill")
+    ///         .padding()
+    ///         .background(.teal, in: RoundedRectangle(cornerRadius: 8))
+    ///
+    /// The ``ShapeStyle/teal`` color fills the shape:
+    ///
+    /// ![A screenshot of the flag icon and word on a teal rectangle with
+    /// rounded corners.](View-background-8)
+    ///
+    /// This modifier is a convenience method for placing a single shape behind a view. To
+    /// create a background with other ``View`` types --- or with a stack
+    /// of views --- use ``View/background(alignment:content:)`` instead.
+    /// To add a ``ShapeStyle`` as a background, use
+    /// ``View/background(_:ignoresSafeAreaEdges:)``.
+    ///
+    /// - Parameters:
+    ///   - style: A ``ShapeStyle`` that OpenSwiftUI uses to the fill the shape
+    ///     that you specify.
+    ///   - shape: An instance of a type that conforms to ``InsettableShape``
+    ///     that OpenSwiftUI draws behind the view.
+    ///   - fillStyle: The ``FillStyle`` to use when drawing the shape.
+    ///     The default style uses the nonzero winding number rule and
+    ///     antialiasing.
+    ///
+    /// - Returns: A view with the specified insettable shape drawn behind it.
+    @inlinable
+    nonisolated public func background<S, T>(_ style: S, in shape: T, fillStyle: FillStyle = FillStyle()) -> some View where S: ShapeStyle, T: InsettableShape {
+        modifier(_InsettableBackgroundShapeModifier(style: style, shape: shape, fillStyle: fillStyle))
+    }
+}
+
+// MARK: - _ViewInputs + applyBackgroundStyle
+
+extension _ViewInputs {
+    fileprivate mutating func applyBackgroundStyle<Value, Style>(
+        value: Attribute<Value>,
+        offset: PointerOffset<Value, Style>
+    ) where Style: ShapeStyle {
+        var type = _ShapeStyle_ShapeType(operation: .modifiesBackground, result: .none)
+        Style._apply(to: &type)
+        guard case .bool(true) = type.result else {
+            return
+        }
+        environment = Attribute(ForegroundEnvironment(
+            style: value.applying(offset: offset),
+            environment: environment
+        ))
+    }
+}
+
+private struct ForegroundEnvironment<Style>: Rule, AsyncAttribute where Style: ShapeStyle {
+    @Attribute var style: Style
+    @Attribute var environment: EnvironmentValues
+
+    var value: EnvironmentValues {
+        var shape = _ShapeStyle_Shape(
+            operation: .modifyBackground(level: 0),
+            environment: environment
+        )
+        style._apply(to: &shape)
+        return shape.environment
+    }
 }
diff --git a/Sources/OpenSwiftUICore/Modifier/ViewModifier/OverlayModifier.swift b/Sources/OpenSwiftUICore/Modifier/ViewModifier/OverlayModifier.swift
index bb0b3957e..67180192c 100644
--- a/Sources/OpenSwiftUICore/Modifier/ViewModifier/OverlayModifier.swift
+++ b/Sources/OpenSwiftUICore/Modifier/ViewModifier/OverlayModifier.swift
@@ -2,12 +2,13 @@
 //  OverlayModifier.swift
 //  OpenSwiftUICore
 //
-//  Status: WIP
+//  Audited for 6.5.4
+//  Status: Complte
 
-import Foundation
+public import Foundation
 package import OpenAttributeGraphShims
 
-// MARK: - makeSecondaryLayerView [6.4.41]
+// MARK: - makeSecondaryLayerView
 
 package func makeSecondaryLayerView<SecondaryLayer>(
     secondaryLayer: Attribute<SecondaryLayer>,
@@ -49,10 +50,11 @@ package func makeSecondaryLayerView<SecondaryLayer>(
     return result
 }
 
-// MARK: - OverlayModifier [6.4.41]
+// MARK: - OverlayModifier
 
 /// A modifier that layers a secondary view in front of the primary content it
 /// modifies, while maintaining the layout characteristics of the primary view.
+@available(OpenSwiftUI_v1_0, *)
 @frozen
 public struct _OverlayModifier<Overlay>: ViewModifier, MultiViewModifier, PrimitiveViewModifier where Overlay: View {
     public var overlay: Overlay
@@ -85,9 +87,85 @@ public struct _OverlayModifier<Overlay>: ViewModifier, MultiViewModifier, Primit
 @available(*, unavailable)
 extension _OverlayModifier: Sendable {}
 
-// TODO
+@available(OpenSwiftUI_v1_0, *)
+extension _OverlayModifier: Equatable where Overlay: Equatable {
+    nonisolated public static func == (a: _OverlayModifier<Overlay>, b: _OverlayModifier<Overlay>) -> Bool {
+        a.overlay == b.overlay && a.alignment == b.alignment
+    }
+}
+
+// MARK: - OverlayStyleModifier
+
+@available(OpenSwiftUI_v3_0, *)
+@frozen
+public struct _OverlayStyleModifier<Style>: ViewModifier, MultiViewModifier, PrimitiveViewModifier where Style: ShapeStyle {
+    public var style: Style
+
+    public var ignoresSafeAreaEdges: Edge.Set
+
+    @inlinable
+    public init(style: Style, ignoresSafeAreaEdges: Edge.Set) {
+        self.style = style
+        self.ignoresSafeAreaEdges = ignoresSafeAreaEdges
+    }
+
+    nonisolated public static func _makeView(
+        modifier: _GraphValue<Self>,
+        inputs: _ViewInputs,
+        body: @escaping (_Graph, _ViewInputs) -> _ViewOutputs
+    ) -> _ViewOutputs {
+        _BackgroundStyleModifier.makeShapeView(
+            modifier: modifier.unsafeBitCast(to: _BackgroundStyleModifier<Style>.self),
+            inputs: inputs,
+            shapeIsBackground: false,
+            body: body
+        )
+    }
+
+    public typealias Body = Never
+}
+
+@available(*, unavailable)
+extension _OverlayStyleModifier: Sendable {}
+
+// MARK: - OverlayShapeModifier
+
+@available(OpenSwiftUI_v3_0, *)
+@frozen
+public struct _OverlayShapeModifier<Style, Bounds>: ViewModifier, MultiViewModifier, PrimitiveViewModifier where Style: ShapeStyle, Bounds: Shape {
+    public var style: Style
+
+    public var shape: Bounds
+
+    public var fillStyle: FillStyle
+
+    @inlinable
+    public init(style: Style, shape: Bounds, fillStyle: FillStyle) {
+        self.style = style
+        self.shape = shape
+        self.fillStyle = fillStyle
+    }
+
+    nonisolated public static func _makeView(
+        modifier: _GraphValue<Self>,
+        inputs: _ViewInputs,
+        body: @escaping (_Graph, _ViewInputs) -> _ViewOutputs
+    ) -> _ViewOutputs {
+        _BackgroundShapeModifier.makeShapeView(
+            modifier: modifier.unsafeBitCast(to: _BackgroundShapeModifier<Style, Bounds>.self),
+            inputs: inputs,
+            shapeIsBackground: false,
+            body: body
+        )
+    }
+
+    public typealias Body = Never
+}
+
+@available(*, unavailable)
+extension _OverlayShapeModifier: Sendable {}
 
-// MARK: - View + Overlay [6.4.41] [WIP]
+// MARK: - View + Overlay
 
 @available(OpenSwiftUI_v1_0, *)
 extension View {
@@ -116,6 +194,43 @@ extension View {
     nonisolated public func overlay<Overlay>(_ overlay: Overlay, alignment: Alignment = .center) -> some View where Overlay: View {
         modifier(_OverlayModifier(overlay: overlay, alignment: alignment))
     }
+
+    /// Adds a border to this view with the specified style and width.
+    ///
+    /// Use this modifier to draw a border of a specified width around the
+    /// view's frame. By default, the border appears inside the bounds of this
+    /// view. For example, you can add a four-point wide border covers the text:
+    ///
+    ///     Text("Purple border inside the view bounds.")
+    ///         .border(Color.purple, width: 4)
+    ///
+    /// ![A screenshot showing the text Purple border inside the view bounds.
+    /// The text is surrounded by a purple border that outlines the text,
+    /// but isn't quite big enough and encroaches on the text.](View-border-1)
+    ///
+    /// To place a border around the outside of this view, apply padding of the
+    /// same width before adding the border:
+    ///
+    ///     Text("Purple border outside the view bounds.")
+    ///         .padding(4)
+    ///         .border(Color.purple, width: 4)
+    ///
+    /// ![A screenshot showing the text Purple border outside the view bounds.
+    /// The text is surrounded by a purple border that outlines the text
+    /// without touching the text.](View-border-2)
+    ///
+    /// - Parameters:
+    ///   - content: A value that conforms to the ``ShapeStyle`` protocol,
+    ///     like a ``Color`` or ``HierarchicalShapeStyle``, that OpenSwiftUI
+    ///     uses to fill the border.
+    ///   - width: The thickness of the border. The default is 1 pixel.
+    ///
+    /// - Returns: A view that adds a border with the specified style and width
+    ///   to this view.
+    @inlinable
+    nonisolated public func border<S>(_ content: S, width: CGFloat = 1) -> some View where S: ShapeStyle {
+        overlay(Rectangle().strokeBorder(content, lineWidth: width))
+    }
 }
 
 @available(OpenSwiftUI_v3_0, *)
@@ -239,9 +354,111 @@ extension View {
     nonisolated public func overlay<V>(alignment: Alignment = .center, @ViewBuilder content: () -> V) -> some View where V: View {
         modifier(_OverlayModifier(overlay: content(), alignment: alignment))
     }
+
+    /// Layers the specified style in front of this view.
+    ///
+    /// Use this modifier to layer a type that conforms to the ``ShapeStyle``
+    /// protocol, like a ``Color``, ``Material``, or ``HierarchicalShapeStyle``,
+    /// in front of a view. For example, you can overlay the
+    /// ``ShapeStyle/ultraThinMaterial`` over a ``Circle``:
+    ///
+    ///     struct CoveredCircle: View {
+    ///         var body: some View {
+    ///             Circle()
+    ///                 .frame(width: 300, height: 200)
+    ///                 .overlay(.ultraThinMaterial)
+    ///         }
+    ///     }
+    ///
+    /// OpenSwiftUI anchors the style to the view's bounds. For the example above,
+    /// the overlay fills the entirety of the circle's frame (which happens
+    /// to be wider than the circle is tall):
+    ///
+    /// ![A screenshot of a circle showing through a rectangle that imposes
+    /// a blurring effect.](View-overlay-5)
+    ///
+    /// OpenSwiftUI also limits the style's extent to the view's
+    /// container-relative shape. You can see this effect if you constrain the
+    /// `CoveredCircle` view with a ``View/containerShape(_:)`` modifier:
+    ///
+    ///     CoveredCircle()
+    ///         .containerShape(RoundedRectangle(cornerRadius: 30))
+    ///
+    /// The overlay takes on the specified container shape:
+    ///
+    /// ![A screenshot of a circle showing through a rounded rectangle that
+    /// imposes a blurring effect.](View-overlay-6)
+    ///
+    /// By default, the overlay ignores safe area insets on all edges, but you
+    /// can provide a specific set of edges to ignore, or an empty set to
+    /// respect safe area insets on all edges:
+    ///
+    ///     Rectangle()
+    ///         .overlay(
+    ///             .secondary,
+    ///             ignoresSafeAreaEdges: []) // Ignore no safe area insets.
+    ///
+    /// If you want to specify a ``View`` or a stack of views as the overlay
+    /// rather than a style, use ``View/overlay(alignment:content:)`` instead.
+    /// If you want to specify a ``Shape``, use
+    /// ``View/overlay(_:in:fillStyle:)``.
+    ///
+    /// - Parameters:
+    ///   - style: An instance of a type that conforms to ``ShapeStyle`` that
+    ///     OpenSwiftUI layers in front of the modified view.
+    ///   - edges: The set of edges for which to ignore safe area insets
+    ///     when adding the overlay. The default value is ``Edge/Set/all``.
+    ///     Specify an empty set to respect safe area insets on all edges.
+    ///
+    /// - Returns: A view with the specified style drawn in front of it.
+    @inlinable
+    nonisolated public func overlay<S>(_ style: S, ignoresSafeAreaEdges edges: Edge.Set = .all) -> some View where S: ShapeStyle {
+        modifier(_OverlayStyleModifier(style: style, ignoresSafeAreaEdges: edges))
+    }
+
+    /// Layers a shape that you specify in front of this view.
+    ///
+    /// Use this modifier to layer a type that conforms to the ``Shape``
+    /// protocol --- like a ``Rectangle``, ``Circle``, or ``Capsule`` --- in
+    /// front of a view. Specify a ``ShapeStyle`` that's used to fill the shape.
+    /// For example, you can overlay the outline of one rectangle in front of
+    /// another:
+    ///
+    ///     Rectangle()
+    ///         .frame(width: 200, height: 100)
+    ///         .overlay(.teal, in: Rectangle().inset(by: 10).stroke(lineWidth: 5))
+    ///
+    /// The example above uses the ``InsettableShape/inset(by:)`` method to
+    /// slightly reduce the size of the overlaid rectangle, and the
+    /// ``Shape/stroke(lineWidth:)`` method to fill only the shape's outline.
+    /// This creates an inset border:
+    ///
+    /// ![A screenshot of a rectangle with a teal border that's
+    /// inset from the edge.](View-overlay-7)
+    ///
+    /// This modifier is a convenience method for layering a shape over a view.
+    /// To handle the more general case of overlaying a ``View`` --- or a stack
+    /// of views --- with control over the position, use
+    /// ``View/overlay(alignment:content:)`` instead. To cover a view with a
+    /// ``ShapeStyle``, use ``View/overlay(_:ignoresSafeAreaEdges:)``.
+    ///
+    /// - Parameters:
+    ///   - style: A ``ShapeStyle`` that OpenSwiftUI uses to fill the shape
+    ///     that you specify.
+    ///   - shape: An instance of a type that conforms to ``Shape`` that
+    ///     OpenSwiftUI draws in front of the view.
+    ///   - fillStyle: The ``FillStyle`` to use when drawing the shape.
+    ///     The default style uses the nonzero winding number rule and
+    ///     antialiasing.
+    ///
+    /// - Returns: A view with the specified shape drawn in front of it.
+    @inlinable
+    nonisolated public func overlay<S, T>(_ style: S, in shape: T, fillStyle: FillStyle = FillStyle()) -> some View where S: ShapeStyle, T: Shape {
+        modifier(_OverlayShapeModifier(style: style, shape: shape, fillStyle: fillStyle))
+    }
 }
 
-// MARK: - SecondaryLayerGeometryQuery [6.4.41]
+// MARK: - SecondaryLayerGeometryQuery
 
 package struct SecondaryLayerGeometryQuery: Rule, AsyncAttribute {
     @OptionalAttribute
diff --git a/Sources/OpenSwiftUICore/Shape/ContainerShape.swift b/Sources/OpenSwiftUICore/Shape/ContainerShape.swift
new file mode 100644
index 000000000..2b14c0978
--- /dev/null
+++ b/Sources/OpenSwiftUICore/Shape/ContainerShape.swift
@@ -0,0 +1,363 @@
+//
+//  ContainerShape.swift
+//  OpenSwiftUICore
+//
+//  Audited for 6.5.4
+//  Status: Complete
+//  ID: E7F652304F78E63E0DE3A54ABB60E18A (SwiftUICore)
+
+public import Foundation
+import OpenAttributeGraphShims
+
+// MARK: - ContainerRelativeShape
+
+/// A shape that is replaced by an inset version of the current
+/// container shape. If no container shape was defined, is replaced by
+/// a rectangle.
+@available(OpenSwiftUI_v2_0, *)
+@frozen
+public struct ContainerRelativeShape: Shape {
+    nonisolated public func path(in rect: CGRect) -> Path {
+        guard let proxy = GeometryProxy.current else {
+            return Path(rect)
+        }
+        let containerShape = proxy.environment.containerShape
+        return containerShape.path(in: rect, proxy: proxy)
+    }
+
+    @inlinable
+    public init() {}
+}
+
+@available(OpenSwiftUI_v2_0, *)
+extension Shape where Self == ContainerRelativeShape {
+    /// A shape that is replaced by an inset version of the current
+    /// container shape. If no container shape was defined, is replaced by
+    /// a rectangle.
+    @_alwaysEmitIntoClient
+    public static var containerRelative: ContainerRelativeShape {
+        .init()
+    }
+}
+
+@available(OpenSwiftUI_v2_0, *)
+extension ContainerRelativeShape: InsettableShape {
+    @inlinable
+    nonisolated public func inset(by amount: CGFloat) -> some InsettableShape {
+        _Inset(amount: amount)
+    }
+
+    @usableFromInline
+    @frozen
+    struct _Inset: InsettableShape {
+        @usableFromInline
+        var amount: CGFloat
+
+        @inlinable
+        init(amount: CGFloat) {
+            self.amount = amount
+        }
+
+        @usableFromInline
+        nonisolated func path(in rect: CGRect) -> Path {
+            ContainerRelativeShape().path(in: rect.insetBy(dx: amount, dy: amount))
+        }
+
+        @usableFromInline
+        var animatableData: CGFloat {
+            get { amount }
+            set { amount = newValue }
+        }
+
+        @inlinable
+        nonisolated func inset(by amount: CGFloat) -> ContainerRelativeShape._Inset {
+            var copy = self
+            copy.amount += amount
+            return copy
+        }
+    }
+}
+
+@available(OpenSwiftUI_v2_0, *)
+extension ShapeStyle {
+    public func _fillingContainerShape() -> some View {
+        ContainerRelativeShape().fill(self)
+    }
+}
+
+// MARK: - View + ContainerShape
+
+@available(OpenSwiftUI_v3_0, *)
+extension View {
+    /// Sets the container shape to use for any container relative shape
+    /// within this view.
+    ///
+    /// The example below defines a view that shows its content with a rounded
+    /// rectangle background and the same container shape. Any
+    /// ``ContainerRelativeShape`` within the `content` matches the rounded
+    /// rectangle shape from this container inset as appropriate.
+    ///
+    ///     struct PlatterContainer<Content: View> : View {
+    ///         @ViewBuilder var content: Content
+    ///         var body: some View {
+    ///             content
+    ///                 .padding()
+    ///                 .containerShape(shape)
+    ///                 .background(shape.fill(.background))
+    ///         }
+    ///         var shape: RoundedRectangle { RoundedRectangle(cornerRadius: 20) }
+    ///     }
+    ///
+    /// - SeeAlso: ``View/containerShape(_:)-(RoundedRectangularShape)``
+    @inlinable
+    nonisolated public func containerShape<T>(_ shape: T) -> some View where T: InsettableShape {
+        modifier(_ContainerShapeModifier(shape: shape))
+    }
+}
+
+@available(OpenSwiftUI_v2_0, *)
+extension View {
+    public func _containerShape<T>(_ shape: T) -> some View where T: InsettableShape {
+        modifier(SystemContainerShapeModifier(shape: shape))
+    }
+}
+
+// MARK: - ContainerShapeModifier
+
+@available(OpenSwiftUI_v3_0, *)
+@frozen
+public struct _ContainerShapeModifier<Shape>: ViewModifier, MultiViewModifier, PrimitiveViewModifier where Shape: InsettableShape {
+    public var shape: Shape
+
+    @inlinable
+    public init(shape: Shape) {
+        self.shape = shape
+    }
+
+    nonisolated public static func _makeView(
+        modifier: _GraphValue<Self>,
+        inputs: _ViewInputs,
+        body: @escaping (_Graph, _ViewInputs) -> _ViewOutputs
+    ) -> _ViewOutputs {
+        var inputs = inputs
+        let shape = Shape.makeAnimatable(
+            value: modifier[offset: { .of(&$0.shape) }],
+            inputs: inputs.base
+        )
+        inputs.setContainerShape(shape, isSystemShape: false)
+        return body(_Graph(), inputs)
+    }
+
+    public typealias Body = Never
+}
+
+@available(*, unavailable)
+extension _ContainerShapeModifier: Sendable {}
+
+// MARK: - AnyContainerShapeType
+
+private protocol AnyContainerShapeType {
+    static func path(
+        in rect: CGRect,
+        proxy: GeometryProxy,
+        shape: AnyWeakAttribute,
+        context: ContainerShapeContext
+    ) -> Path
+
+    #if OPENSWIFTUI_SUPPORT_2026_API
+    static func corners(
+        in rect: CGRect,
+        proxy: GeometryProxy,
+        shape: AnyWeakAttribute,
+        context: ContainerShapeContext,
+        corners: RoundedRectangularShapeCorners,
+        uniformity: ConcentricRectangle.Uniformity
+    ) -> RectangleCornerRadii?
+
+    static func corners(
+        in size: CGSize?,
+        shape: AnyWeakAttribute,
+        context: ContainerShapeContext,
+    ) -> RectangleCornerRadii?
+    #endif
+}
+
+// MARK: - SystemContainerShapeModifier
+
+private struct SystemContainerShapeModifier<Shape>: ViewModifier, MultiViewModifier, PrimitiveViewModifier where Shape: InsettableShape {
+    var shape: Shape
+
+    nonisolated static func _makeView(
+        modifier: _GraphValue<Self>,
+        inputs: _ViewInputs,
+        body: @escaping (_Graph, _ViewInputs) -> _ViewOutputs
+    ) -> _ViewOutputs {
+        var inputs = inputs
+        let shape = Shape.makeAnimatable(
+            value: modifier[offset: { .of(&$0.shape) }],
+            inputs: inputs.base
+        )
+        inputs.setContainerShape(shape, isSystemShape: true)
+        return body(_Graph(), inputs)
+    }
+
+    typealias Body = Never
+}
+
+// MARK: - ImplicitContainerShape
+
+package struct ImplicitContainerShape: Shape {
+    package init() {}
+
+    nonisolated package func path(in rect: CGRect) -> Path {
+        guard let proxy = GeometryProxy.current else {
+            return Path(rect)
+        }
+        let data = proxy.environment.containerShape
+        guard !data.isSystemShape else {
+            return Path(rect)
+        }
+        return data.path(in: rect, proxy: proxy)
+    }
+}
+
+// MARK: - ContainerShape Support
+
+extension _ViewInputs {
+    mutating func setContainerShape<S>(_ shape: Attribute<S>, isSystemShape: Bool) where S: InsettableShape {
+        guard S.self != ContainerRelativeShape.self else {
+            return
+        }
+        let id = UniqueID()
+        let childTransform = Attribute(ContainerShapeTransform(
+            transform: transform,
+            position: animatedPosition(),
+            id: id
+        ))
+        transform = childTransform
+        environment = Attribute(ContainerShapeEnvironment(
+            environment: environment,
+            data: ContainerShapeData(
+                type: ContainerShapeType<S>.self,
+                shape: AnyWeakAttribute(shape.identifier),
+                context: ContainerShapeContext(
+                    id: id,
+                    position: WeakAttribute(animatedPosition()),
+                    size: WeakAttribute(animatedSize()),
+                    childTransform: WeakAttribute(childTransform)
+                ),
+                isSystemShape: isSystemShape
+            )
+        ))
+        needsGeometry = true
+    }
+}
+
+private struct ContainerShapeEnvironment: Rule, AsyncAttribute {
+    @Attribute var environment: EnvironmentValues
+    var data: ContainerShapeData
+
+    var value: EnvironmentValues {
+        var environment = environment
+        environment.containerShape = data
+        return environment
+    }
+}
+
+private struct ContainerShapeType<Shape>: AnyContainerShapeType where Shape: InsettableShape {
+    static func path(
+        in rect: CGRect,
+        proxy: GeometryProxy,
+        shape: AnyWeakAttribute,
+        context: ContainerShapeContext
+    ) -> Path {
+        var result: Path?
+        proxy.context.update {
+            guard let size = context.size?.value,
+                  let shape = shape.unsafeCast(to: Shape.self).value
+            else {
+                result = Path(rect)
+                return
+            }
+            let convertedRect = context.convert(rect, to: proxy)
+            let bounds = CGRect(origin: .zero, size: size)
+            let inset = max(
+                CGFloat.zero,
+                min(
+                    convertedRect.minX - bounds.minX,
+                    convertedRect.minY - bounds.minY,
+                    bounds.maxX - convertedRect.maxX,
+                    bounds.maxY - convertedRect.maxY
+                )
+            )
+            result = shape.inset(by: inset).path(in: rect.insetBy(dx: -inset, dy: -inset))
+        }
+        return result!
+    }
+}
+
+private struct DefaultContainerShapeType: AnyContainerShapeType {
+    static func path(
+        in rect: CGRect,
+        proxy: GeometryProxy,
+        shape: AnyWeakAttribute,
+        context: ContainerShapeContext
+    ) -> Path {
+        Path(rect)
+    }
+}
+
+private struct ContainerShapeTransform: Rule, AsyncAttribute {
+    @Attribute var transform: ViewTransform
+    @Attribute var position: ViewOrigin
+    var id: UniqueID
+
+    var value: ViewTransform {
+        var transform = transform.withPosition(position)
+        transform.appendCoordinateSpace(name: id)
+        return transform
+    }
+}
+
+private struct ContainerShapeData {
+    var type: any AnyContainerShapeType.Type = DefaultContainerShapeType.self
+    var shape: AnyWeakAttribute = .init()
+    var context: ContainerShapeContext = .init()
+    var isSystemShape: Bool = false
+
+    @inline(__always)
+    func path(in rect: CGRect, proxy: GeometryProxy) -> Path {
+        type.path(in: rect, proxy: proxy, shape: shape, context: context)
+    }
+}
+
+private struct ContainerShapeKey: EnvironmentKey {
+    static var defaultValue: ContainerShapeData { .init() }
+}
+
+extension EnvironmentValues {
+    @inline(__always)
+    fileprivate var containerShape: ContainerShapeData {
+        get { self[ContainerShapeKey.self] }
+        set { self[ContainerShapeKey.self] = newValue }
+    }
+}
+
+private struct ContainerShapeContext {
+    var id: UniqueID = .invalid
+    @WeakAttribute var position: ViewOrigin?
+    @WeakAttribute var size: ViewSize?
+    @WeakAttribute var childTransform: ViewTransform?
+
+    func convert(_ rect: CGRect, to proxy: GeometryProxy) -> CGRect {
+        if proxy._transform == _childTransform,
+           let proxyPosition = proxy._position.value,
+           let position = _position.value {
+            var rect = rect
+            rect.origin += proxyPosition - position
+            return rect
+        } else {
+            return proxy.rect(rect, in: .named(id))
+        }
+    }
+}
diff --git a/Sources/OpenSwiftUICore/Shape/ShapeStyle/AnchorShapeStyle.swift b/Sources/OpenSwiftUICore/Shape/ShapeStyle/AnchorShapeStyle.swift
new file mode 100644
index 000000000..d3f3015da
--- /dev/null
+++ b/Sources/OpenSwiftUICore/Shape/ShapeStyle/AnchorShapeStyle.swift
@@ -0,0 +1,177 @@
+//
+//  AnchorShapeStyle.swift
+//  OpenSwiftUICore
+//
+//  Audited for 6.5.4
+//  Status: Complete
+
+public import Foundation
+
+// MARK: - _AnchoredShapeStyle
+
+/// Paint adaptor to override the unit space to absolute space
+/// coordinate conversion.
+@available(OpenSwiftUI_v1_0, *)
+@frozen
+public struct _AnchoredShapeStyle<S>: ShapeStyle where S: ShapeStyle {
+    public var style: S
+
+    public var bounds: CGRect
+
+    @inlinable
+    init(style: S, bounds: CGRect) {
+        self.style = style
+        self.bounds = bounds
+    }
+
+    nonisolated public static func _makeView<T>(
+        view: _GraphValue<_ShapeView<T, _AnchoredShapeStyle<S>>>,
+        inputs: _ViewInputs
+    ) -> _ViewOutputs where T: Shape {
+        legacyMakeShapeView(view: view, inputs: inputs)
+    }
+
+    @available(OpenSwiftUI_v5_0, *)
+    public typealias Resolved = Never
+}
+
+@available(OpenSwiftUI_v3_0, *)
+extension _AnchoredShapeStyle {
+    public func _apply(to shape: inout _ShapeStyle_Shape) {
+        shape.bounds = bounds
+        style._apply(to: &shape)
+    }
+
+    public static func _apply(to type: inout _ShapeStyle_ShapeType) {
+        S._apply(to: &type)
+    }
+}
+
+// MARK: - AnchoredResolvedPaint
+
+package struct AnchoredResolvedPaint<P>: ResolvedPaint where P: ResolvedPaint {
+    package var paint: P
+
+    package var bounds: CGRect
+
+    package init(_ paint: P, bounds: CGRect) {
+        self.paint = paint
+        self.bounds = bounds
+    }
+
+    package func draw(
+        path: Path,
+        style: PathDrawingStyle,
+        in ctx: GraphicsContext,
+        bounds outerBounds: CGRect?
+    ) {
+        paint.draw(path: path, style: style, in: ctx, bounds: bounds)
+    }
+
+    package var isClear: Bool {
+        paint.isClear
+    }
+
+    package var isOpaque: Bool {
+        paint.isOpaque
+    }
+
+    package var isCALayerCompatible: Bool {
+        paint.isCALayerCompatible
+    }
+
+    package typealias AnimatableData = AnimatablePair<P.AnimatableData, CGRect.AnimatableData>
+
+    package var animatableData: AnimatableData {
+        get {
+            AnimatableData(paint.animatableData, bounds.animatableData)
+        }
+        set {
+            paint.animatableData = newValue.first
+            bounds.animatableData = newValue.second
+        }
+    }
+
+    package static var leafProtobufTag: CodableResolvedPaint.Tag? {
+        nil
+    }
+
+    package static func == (a: AnchoredResolvedPaint<P>, b: AnchoredResolvedPaint<P>) -> Bool {
+        a.paint == b.paint && a.bounds == b.bounds
+    }
+}
+
+extension AnchoredResolvedPaint: ProtobufEncodableMessage {
+    package func encode(to encoder: inout ProtobufEncoder) throws {
+        try paint.encodePaint(to: &encoder)
+        try encoder.messageField(7, EdgeInsets(
+            top: bounds.origin.x,
+            leading: bounds.origin.y,
+            bottom: bounds.size.width,
+            trailing: bounds.size.height
+        ))
+    }
+}
+
+// MARK: - ShapeStyle + Anchor
+
+@available(OpenSwiftUI_v1_0, *)
+extension ShapeStyle {
+    /// Maps a shape style's unit-space coordinates to the absolute coordinates
+    /// of a given rectangle.
+    ///
+    /// Some shape styles have colors or patterns that vary
+    /// with position based on ``UnitPoint`` coordinates. For example, you
+    /// can create a ``LinearGradient`` using ``UnitPoint/top`` and
+    /// ``UnitPoint/bottom`` as the start and end points:
+    ///
+    ///     let gradient = LinearGradient(
+    ///         colors: [.red, .yellow],
+    ///         startPoint: .top,
+    ///         endPoint: .bottom)
+    ///
+    /// When rendering such styles, OpenSwiftUI maps the unit space coordinates to
+    /// the absolute coordinates of the filled shape. However, you can tell
+    /// OpenSwiftUI to use a different set of coordinates by supplying a rectangle
+    /// to the `in(_:)` method. Consider two resizable rectangles using the
+    /// gradient defined above:
+    ///
+    ///     HStack {
+    ///         Rectangle()
+    ///             .fill(gradient)
+    ///         Rectangle()
+    ///             .fill(gradient.in(CGRect(x: 0, y: 0, width: 0, height: 300)))
+    ///     }
+    ///     .onTapGesture { isBig.toggle() }
+    ///     .frame(height: isBig ? 300 : 50)
+    ///     .animation(.easeInOut)
+    ///
+    /// When `isBig` is true — defined elsewhere as a private ``State``
+    /// variable — the rectangles look the same, because their heights
+    /// match that of the modified gradient:
+    ///
+    /// ![Two identical, tall rectangles, with a gradient that starts red at
+    /// the top and transitions to yellow at the bottom.](ShapeStyle-in-1)
+    ///
+    /// When the user toggles `isBig` by tapping the ``HStack``, the
+    /// rectangles shrink, but the gradients each react in a different way:
+    ///
+    /// ![Two short rectangles with different coloration. The first has a
+    /// gradient that transitions top to bottom from full red to full yellow.
+    /// The second starts as red at the top and then begins to transition
+    /// to yellow toward the bottom.](ShapeStyle-in-2)
+    ///
+    /// OpenSwiftUI remaps the gradient of the first rectangle to the new frame
+    /// height, so that you continue to see the full range of colors in a
+    /// smaller area. For the second rectangle, the modified gradient retains
+    /// a mapping to the full height, so you instead see only a small part of
+    /// the overall gradient. Animation helps to visualize the difference.
+    ///
+    /// - Parameter rect: A rectangle that gives the absolute coordinates over
+    ///   which to map the shape style.
+    /// - Returns: A new shape style mapped to the coordinates given by `rect`.
+    @inlinable
+    public func `in`(_ rect: CGRect) -> some ShapeStyle {
+        _AnchoredShapeStyle(style: self, bounds: rect)
+    }
+}