diff --git a/Scripts/openswiftui_swiftinterface.sh b/Scripts/openswiftui_swiftinterface.sh
index 21f60ad2..f411ad04 100755
--- a/Scripts/openswiftui_swiftinterface.sh
+++ b/Scripts/openswiftui_swiftinterface.sh
@@ -9,4 +9,4 @@ OPENSWIFTUI_ROOT="$(dirname $(dirname $(filepath $0)))"
 
 cd $OPENSWIFTUI_ROOT
 
-swift build -Xswiftc -emit-module-interface -Xswiftc -enable-library-evolution
+swift build -Xswiftc -emit-module-interface -Xswiftc -enable-library-evolution  -Xswiftc -no-verify-emitted-module-interface
\ No newline at end of file
diff --git a/Sources/OpenSwiftUICore/Data/Environment/EnvironmentKey.swift b/Sources/OpenSwiftUICore/Data/Environment/EnvironmentKey.swift
index dfa65ecc..41193115 100644
--- a/Sources/OpenSwiftUICore/Data/Environment/EnvironmentKey.swift
+++ b/Sources/OpenSwiftUICore/Data/Environment/EnvironmentKey.swift
@@ -12,12 +12,9 @@ public protocol EnvironmentKey {
 
     static var defaultValue: Value { get }
     
-    #if OPENSWIFTUI_SUPPORT_2022_API
     static func _valuesEqual(_ lhs: Self.Value, _ rhs: Self.Value) -> Bool
-    #endif
 }
 
-#if OPENSWIFTUI_SUPPORT_2022_API
 extension EnvironmentKey {
     public static func _valuesEqual(_ lhs: Self.Value, _ rhs: Self.Value) -> Bool {
         compareValues(lhs, rhs)
@@ -29,7 +26,6 @@ extension EnvironmentKey where Value: Equatable {
         lhs == rhs
     }
 }
-#endif
 
 package protocol DerivedEnvironmentKey {
     associatedtype Value: Equatable
diff --git a/Sources/OpenSwiftUICore/EventHandling/InputEvent/HitTesting/ContentResponder.swift b/Sources/OpenSwiftUICore/EventHandling/InputEvent/HitTesting/ContentResponder.swift
index 39a44b7f..762df482 100644
--- a/Sources/OpenSwiftUICore/EventHandling/InputEvent/HitTesting/ContentResponder.swift
+++ b/Sources/OpenSwiftUICore/EventHandling/InputEvent/HitTesting/ContentResponder.swift
@@ -5,10 +5,10 @@
 //  Audited for iOS 15.5
 //  Status: WIP
 
-import Foundation
+package import Foundation
 import OpenSwiftUI_SPI
 
-protocol ContentResponder {
+package protocol ContentResponder {
     func contains(points: [CGPoint], size: CGSize) -> BitVector64
     func contentPath(size: CGSize) -> Path
     func contentPath(size: CGSize, kind: ContentShapeKinds) -> Path
diff --git a/Sources/OpenSwiftUICore/Render/ColorRenderingMode.swift b/Sources/OpenSwiftUICore/Graphic/Color/ColorRenderingMode.swift
similarity index 94%
rename from Sources/OpenSwiftUICore/Render/ColorRenderingMode.swift
rename to Sources/OpenSwiftUICore/Graphic/Color/ColorRenderingMode.swift
index f4bbf55a..578908fa 100644
--- a/Sources/OpenSwiftUICore/Render/ColorRenderingMode.swift
+++ b/Sources/OpenSwiftUICore/Graphic/Color/ColorRenderingMode.swift
@@ -29,9 +29,6 @@ public enum ColorRenderingMode: Sendable {
     case extendedLinear
 }
 
-extension ColorRenderingMode: Equatable {}
-extension ColorRenderingMode: Hashable {}
-
 extension ColorRenderingMode: ProtobufEnum {
     package var protobufValue: UInt {
         switch self {
diff --git a/Sources/OpenSwiftUICore/Graphic/GraphicsContext.swift b/Sources/OpenSwiftUICore/Graphic/GraphicsContext.swift
new file mode 100644
index 00000000..20e0f2ad
--- /dev/null
+++ b/Sources/OpenSwiftUICore/Graphic/GraphicsContext.swift
@@ -0,0 +1,482 @@
+//
+//  GraphicsContext.swift
+//  OpenSwiftUICore
+//
+//  Audited for iOS 18.0
+//  Status: WIP
+
+#if canImport(Darwin)
+public import CoreGraphics
+#else
+public enum CGBlendMode: Int32, @unchecked Sendable {
+    case normal = 0
+    case multiply = 1
+    case screen = 2
+    case overlay = 3
+    case darken = 4
+    case lighten = 5
+    case colorDodge = 6
+    case colorBurn = 7
+    case softLight = 8
+    case hardLight = 9
+    case difference = 10
+    case exclusion = 11
+    case hue = 12
+    case saturation = 13
+    case color = 14
+    case luminosity = 15
+    case clear = 16
+    case copy = 17
+    case sourceIn = 18
+    case sourceOut = 19
+    case sourceAtop = 20
+    case destinationOver = 21
+    case destinationIn = 22
+    case destinationOut = 23
+    case destinationAtop = 24
+    case xor = 25
+    case plusDarker = 26
+    case plusLighter = 27
+}
+#endif
+
+/// An immediate mode drawing destination, and its current state.
+///
+/// Use a context to execute 2D drawing primitives. For example, you can draw
+/// filled shapes using the ``fill(_:with:style:)`` method inside a ``Canvas``
+/// view:
+///
+///     Canvas { context, size in
+///         context.fill(
+///             Path(ellipseIn: CGRect(origin: .zero, size: size)),
+///             with: .color(.green))
+///     }
+///     .frame(width: 300, height: 200)
+///
+/// The example above draws an ellipse that just fits inside a canvas that's
+/// constrained to 300 points wide and 200 points tall:
+///
+/// ![A screenshot of a view that shows a green ellipse.](GraphicsContext-1)
+///
+/// In addition to outlining or filling paths, you can draw images, text,
+/// and OpenSwiftUI views. You can also use the context to perform many common
+/// graphical operations, like adding masks, applying filters and
+/// transforms, and setting a blend mode. For example you can add
+/// a mask using the ``clip(to:style:options:)`` method:
+///
+///     let halfSize = size.applying(CGAffineTransform(scaleX: 0.5, y: 0.5))
+///     context.clip(to: Path(CGRect(origin: .zero, size: halfSize)))
+///     context.fill(
+///         Path(ellipseIn: CGRect(origin: .zero, size: size)),
+///         with: .color(.green))
+///
+/// The rectangular mask hides all but one quadrant of the ellipse:
+///
+/// ![A screenshot of a view that shows the upper left quarter of a green
+/// ellipse.](GraphicsContext-2)
+///
+/// The order of operations matters. Changes that you make to the state of
+/// the context, like adding a mask or a filter, apply to later
+/// drawing operations. If you reverse the fill and clip operations in
+/// the example above, so that the fill comes first, the mask doesn't
+/// affect the ellipse.
+///
+/// Each context references a particular layer in a tree of transparency layers,
+/// and also contains a full copy of the drawing state. You can modify the
+/// state of one context without affecting the state of any other, even if
+/// they refer to the same layer. For example you can draw the masked ellipse
+/// from the previous example into a copy of the main context, and then add a
+/// rectangle into the main context:
+///
+///     // Create a copy of the context to draw a clipped ellipse.
+///     var maskedContext = context
+///     let halfSize = size.applying(CGAffineTransform(scaleX: 0.5, y: 0.5))
+///     maskedContext.clip(to: Path(CGRect(origin: .zero, size: halfSize)))
+///     maskedContext.fill(
+///         Path(ellipseIn: CGRect(origin: .zero, size: size)),
+///         with: .color(.green))
+///
+///     // Go back to the original context to draw the rectangle.
+///     let origin = CGPoint(x: size.width / 4, y: size.height / 4)
+///     context.fill(
+///         Path(CGRect(origin: origin, size: halfSize)),
+///         with: .color(.blue))
+///
+/// The mask doesn't clip the rectangle because the mask isn't part of the
+/// main context. However, both contexts draw into the same view because
+/// you created one context as a copy of the other:
+///
+/// ![A screenshot of a view that shows the upper left quarter of a green
+/// ellipse, overlaid by a blue rectangle centered in the
+/// view.](GraphicsContext-3)
+///
+/// The context has access to an ``EnvironmentValues`` instance called
+/// ``environment`` that's initially copied from the environment of its
+/// enclosing view. OpenSwiftUI uses environment values --- like the display
+/// resolution and color scheme --- to resolve types like ``Image`` and
+/// ``Color`` that appear in the context. You can also access values stored
+/// in the environment for your own purposes.
+@frozen
+public struct GraphicsContext {
+    @usableFromInline
+    final class Storage {
+        
+    }
+    
+    var storage: Storage
+    
+    /// The ways that a graphics context combines new content with background
+    /// content.
+    ///
+    /// Use one of these values to set the
+    /// ``GraphicsContext/blendMode-swift.property`` property of a
+    /// ``GraphicsContext``. The value that you set affects how content
+    /// that you draw replaces or combines with content that you
+    /// previously drew into the context.
+    ///
+    @frozen
+    public struct BlendMode: RawRepresentable, Equatable {
+        public let rawValue: Int32
+        
+        @inlinable
+        public init(rawValue: Int32) { self.rawValue = rawValue }
+        
+        /// A mode that paints source image samples over the background image
+        /// samples.
+        ///
+        /// This is the default blend mode.
+        @inlinable
+        public static var normal: BlendMode {
+            self.init(rawValue: CGBlendMode.normal.rawValue)
+        }
+        
+        /// A mode that multiplies the source image samples with the background
+        /// image samples.
+        ///
+        /// Drawing in this mode results in colors that are at least as
+        /// dark as either of the two contributing sample colors.
+        @inlinable
+        public static var multiply: BlendMode {
+            self.init(rawValue: CGBlendMode.multiply.rawValue)
+        }
+        
+        /// A mode that multiplies the inverse of the source image samples with
+        /// the inverse of the background image samples.
+        ///
+        /// Drawing in this mode results in colors that are at least as light
+        /// as either of the two contributing sample colors.
+        @inlinable
+        public static var screen: BlendMode {
+            self.init(rawValue: CGBlendMode.screen.rawValue)
+        }
+        
+        /// A mode that either multiplies or screens the source image samples
+        /// with the background image samples, depending on the background
+        /// color.
+        ///
+        /// Drawing in this mode overlays the existing image samples
+        /// while preserving the highlights and shadows of the
+        /// background. The background color mixes with the source
+        /// image to reflect the lightness or darkness of the
+        /// background.
+        @inlinable
+        public static var overlay: BlendMode {
+            self.init(rawValue: CGBlendMode.overlay.rawValue)
+        }
+        
+        /// A mode that creates composite image samples by choosing the darker
+        /// samples from either the source image or the background.
+        ///
+        /// When you draw in this mode, source image samples that are darker
+        /// than the background replace the background.
+        /// Otherwise, the background image samples remain unchanged.
+        @inlinable
+        public static var darken: BlendMode {
+            self.init(rawValue: CGBlendMode.darken.rawValue)
+        }
+        
+        /// A mode that creates composite image samples by choosing the lighter
+        /// samples from either the source image or the background.
+        ///
+        /// When you draw in this mode, source image samples that are lighter
+        /// than the background replace the background.
+        /// Otherwise, the background image samples remain unchanged.
+        @inlinable
+        public static var lighten: BlendMode {
+            self.init(rawValue: CGBlendMode.lighten.rawValue)
+        }
+        
+        /// A mode that brightens the background image samples to reflect the
+        /// source image samples.
+        ///
+        /// Source image sample values that
+        /// specify black do not produce a change.
+        @inlinable
+        public static var colorDodge: BlendMode {
+            self.init(rawValue: CGBlendMode.colorDodge.rawValue)
+        }
+
+        /// A mode that darkens background image samples to reflect the source
+        /// image samples.
+        ///
+        /// Source image sample values that specify
+        /// white do not produce a change.
+        @inlinable
+        public static var colorBurn: BlendMode {
+            self.init(rawValue: CGBlendMode.colorBurn.rawValue)
+        }
+
+        /// A mode that either darkens or lightens colors, depending on the
+        /// source image sample color.
+        ///
+        /// If the source image sample color is
+        /// lighter than 50% gray, the background is lightened, similar
+        /// to dodging. If the source image sample color is darker than
+        /// 50% gray, the background is darkened, similar to burning.
+        /// If the source image sample color is equal to 50% gray, the
+        /// background is not changed. Image samples that are equal to
+        /// pure black or pure white produce darker or lighter areas,
+        /// but do not result in pure black or white. The overall
+        /// effect is similar to what you'd achieve by shining a
+        /// diffuse spotlight on the source image. Use this to add
+        /// highlights to a scene.
+        @inlinable
+        public static var softLight: BlendMode {
+            self.init(rawValue: CGBlendMode.softLight.rawValue)
+        }
+
+        /// A mode that either multiplies or screens colors, depending on the
+        /// source image sample color.
+        ///
+        /// If the source image sample color
+        /// is lighter than 50% gray, the background is lightened,
+        /// similar to screening. If the source image sample color is
+        /// darker than 50% gray, the background is darkened, similar
+        /// to multiplying. If the source image sample color is equal
+        /// to 50% gray, the source image is not changed. Image samples
+        /// that are equal to pure black or pure white result in pure
+        /// black or white. The overall effect is similar to what you'd
+        /// achieve by shining a harsh spotlight on the source image.
+        /// Use this to add highlights to a scene.
+        @inlinable
+        public static var hardLight: BlendMode {
+            self.init(rawValue: CGBlendMode.hardLight.rawValue)
+        }
+
+        /// A mode that subtracts the brighter of the source image sample color
+        /// or the background image sample color from the other.
+        ///
+        /// Source image sample values that are black produce no change; white
+        /// inverts the background color values.
+        @inlinable
+        public static var difference: BlendMode {
+            self.init(rawValue: CGBlendMode.difference.rawValue)
+        }
+
+        /// A mode that produces an effect similar to that produced by the
+        /// difference blend mode, but with lower contrast.
+        ///
+        /// Source image sample values that are black don't produce a change;
+        /// white inverts the background color values.
+        @inlinable
+        public static var exclusion: BlendMode {
+            self.init(rawValue: CGBlendMode.exclusion.rawValue)
+        }
+
+        /// A mode that uses the luminance and saturation values of the
+        /// background with the hue of the source image.
+        @inlinable
+        public static var hue: BlendMode {
+            self.init(rawValue: CGBlendMode.hue.rawValue)
+        }
+
+        /// A mode that uses the luminance and hue values of the background with
+        /// the saturation of the source image.
+        ///
+        /// Areas of the background that have no saturation --- namely,
+        /// pure gray areas --- don't produce a change.
+        @inlinable
+        public static var saturation: BlendMode {
+            self.init(rawValue: CGBlendMode.saturation.rawValue)
+        }
+
+        /// A mode that uses the luminance values of the background with the hue
+        /// and saturation values of the source image.
+        ///
+        /// This mode preserves the gray levels in the image. You can use this
+        /// mode to color monochrome images or to tint color images.
+        @inlinable
+        public static var color: BlendMode {
+            self.init(rawValue: CGBlendMode.color.rawValue)
+        }
+
+        /// A mode that uses the hue and saturation of the background with the
+        /// luminance of the source image.
+        ///
+        /// This mode creates an effect that is inverse to the effect created
+        /// by the ``color`` mode.
+        @inlinable
+        public static var luminosity: BlendMode {
+            self.init(rawValue: CGBlendMode.luminosity.rawValue)
+        }
+
+        /// A mode that clears any pixels that the source image overwrites.
+        ///
+        /// With this mode, you can use the source image like an eraser.
+        ///
+        /// This mode implements the equation `R = 0` where
+        /// `R` is the composite image.
+        @inlinable
+        public static var clear: BlendMode {
+            self.init(rawValue: CGBlendMode.clear.rawValue)
+        }
+
+        /// A mode that replaces background image samples with source image
+        /// samples.
+        ///
+        /// Unlike the ``normal`` mode, the source image completely replaces
+        /// the background, so that even transparent pixels in the source image
+        /// replace opaque pixels in the background, rather than letting the
+        /// background show through.
+        ///
+        /// This mode implements the equation `R = S` where
+        /// * `R` is the composite image.
+        /// * `S` is the source image.
+        @inlinable
+        public static var copy: BlendMode {
+            self.init(rawValue: CGBlendMode.copy.rawValue)
+        }
+
+        /// A mode that you use to paint the source image, including
+        /// its transparency, onto the opaque parts of the background.
+        ///
+        /// This mode implements the equation `R = S*Da` where
+        /// * `R` is the composite image.
+        /// * `S` is the source image.
+        /// * `Da` is the source background's alpha value.
+        @inlinable
+        public static var sourceIn: BlendMode {
+            self.init(rawValue: CGBlendMode.sourceIn.rawValue)
+        }
+
+        /// A mode that you use to paint the source image onto the
+        /// transparent parts of the background, while erasing the background.
+        ///
+        /// This mode implements the equation `R = S*(1 - Da)` where
+        /// * `R` is the composite image.
+        /// * `S` is the source image.
+        /// * `Da` is the source background's alpha value.
+        @inlinable
+        public static var sourceOut: BlendMode {
+            self.init(rawValue: CGBlendMode.sourceOut.rawValue)
+        }
+
+        /// A mode that you use to paint the opaque parts of the
+        /// source image onto the opaque parts of the background.
+        ///
+        /// This mode implements the equation `R = S*Da + D*(1 - Sa)` where
+        /// * `R` is the composite image.
+        /// * `S` is the source image.
+        /// * `D` is the background.
+        /// * `Sa` is the source image's alpha value.
+        /// * `Da` is the source background's alpha value.
+        @inlinable
+        public static var sourceAtop: BlendMode {
+            self.init(rawValue: CGBlendMode.sourceAtop.rawValue)
+        }
+
+        /// A mode that you use to paint the source image under
+        /// the background.
+        ///
+        /// This mode implements the equation `R = S*(1 - Da) + D` where
+        /// * `R` is the composite image.
+        /// * `S` is the source image.
+        /// * `D` is the background.
+        /// * `Da` is the source background's alpha value.
+        @inlinable
+        public static var destinationOver: BlendMode {
+            self.init(rawValue: CGBlendMode.destinationOver.rawValue)
+        }
+
+        /// A mode that you use to erase any of the background that
+        /// isn't covered by opaque source pixels.
+        ///
+        /// This mode implements the equation `R = D*Sa` where
+        /// * `R` is the composite image.
+        /// * `S` is the source image.
+        /// * `Da` is the source background's alpha value.
+        @inlinable
+        public static var destinationIn: BlendMode {
+            self.init(rawValue: CGBlendMode.destinationIn.rawValue)
+        }
+
+        /// A mode that you use to erase any of the background that
+        /// is covered by opaque source pixels.
+        ///
+        /// This mode implements the equation `R = D*(1 - Sa)` where
+        /// * `R` is the composite image.
+        /// * `D` is the background.
+        /// * `Sa` is the source image's alpha value.
+        @inlinable
+        public static var destinationOut: BlendMode {
+            self.init(rawValue: CGBlendMode.destinationOut.rawValue)
+        }
+
+        /// A mode that you use to paint the source image under
+        /// the background, while erasing any of the background not matched
+        /// by opaque pixels from the source image.
+        ///
+        /// This mode implements the equation `R = S*(1 - Da) + D*Sa` where
+        /// * `R` is the composite image.
+        /// * `S` is the source image.
+        /// * `D` is the background.
+        /// * `Sa` is the source image's alpha value.
+        /// * `Da` is the source background's alpha value.
+        @inlinable
+        public static var destinationAtop: BlendMode {
+            self.init(rawValue: CGBlendMode.destinationAtop.rawValue)
+        }
+
+        /// A mode that you use to clear pixels where both the source and
+        /// background images are opaque.
+        ///
+        /// This mode implements the equation `R = S*(1 - Da) + D*(1 - Sa)` where
+        /// * `R` is the composite image.
+        /// * `S` is the source image.
+        /// * `D` is the background.
+        /// * `Sa` is the source image's alpha value.
+        /// * `Da` is the source background's alpha value.
+        ///
+        /// This XOR mode is only nominally related to the classical bitmap
+        /// XOR operation, which OpenSwiftUI doesn't support.
+        @inlinable
+        public static var xor: BlendMode {
+            self.init(rawValue: CGBlendMode.xor.rawValue)
+        }
+
+        /// A mode that adds the inverse of the color components of the source
+        /// and background images, and then inverts the result, producing
+        /// a darkened composite.
+        ///
+        /// This mode implements the equation `R = MAX(0, 1 - ((1 - D) + (1 - S)))` where
+        /// * `R` is the composite image.
+        /// * `S` is the source image.
+        /// * `D` is the background.
+        @inlinable
+        public static var plusDarker: BlendMode {
+            self.init(rawValue: CGBlendMode.plusDarker.rawValue)
+        }
+
+        /// A mode that adds the components of the source and background images,
+        /// resulting in a lightened composite.
+        ///
+        /// This mode implements the equation `R = MIN(1, S + D)` where
+        /// * `R` is the composite image.
+        /// * `S` is the source image.
+        /// * `D` is the background.
+        @inlinable
+        public static var plusLighter: BlendMode {
+            self.init(rawValue: CGBlendMode.plusLighter.rawValue)
+        }
+    }
+}
diff --git a/Sources/OpenSwiftUICore/Graphic/GraphicsFilter.swift b/Sources/OpenSwiftUICore/Graphic/GraphicsFilter.swift
new file mode 100644
index 00000000..bcea6361
--- /dev/null
+++ b/Sources/OpenSwiftUICore/Graphic/GraphicsFilter.swift
@@ -0,0 +1,51 @@
+//
+//  GraphicsFilter.swift
+//  OpenSwiftUICore
+//
+//  Audited for iOS 18.0
+//  WIP
+
+package enum GraphicsFilter {
+    // TODO
+}
+
+package enum GraphicsBlendMode: Equatable {
+    case blendMode(GraphicsContext.BlendMode)
+    case caFilter(AnyObject)
+    
+    package init(_ mode: BlendMode) {
+        let result: GraphicsContext.BlendMode = switch mode {
+            case .normal: .normal
+            case .multiply: .multiply
+            case .screen: .screen
+            case .overlay: .overlay
+            case .darken: .darken
+            case .lighten: .lighten
+            case .colorDodge: .colorDodge
+            case .colorBurn: .colorBurn
+            case .softLight: .softLight
+            case .hardLight: .hardLight
+            case .difference: .difference
+            case .exclusion: .exclusion
+            case .hue: .hue
+            case .saturation: .saturation
+            case .color: .color
+            case .luminosity: .luminosity
+            case .sourceAtop: .sourceAtop
+            case .destinationOver: .destinationOver
+            case .destinationOut: .destinationOut
+            case .plusDarker: .plusDarker
+            case .plusLighter: .plusLighter
+        }
+        self = .blendMode(result)
+    }
+
+    package static let normal: GraphicsBlendMode = .blendMode(.normal)
+    package static func == (lhs: GraphicsBlendMode, rhs: GraphicsBlendMode) -> Bool {
+        switch (lhs, rhs) {
+            case (.blendMode(let lhs), .blendMode(let rhs)): lhs == rhs
+            case (.caFilter(let lhs), .caFilter(let rhs)): lhs === rhs
+            default: false
+        }
+    }
+}
diff --git a/Sources/OpenSwiftUICore/Graphic/ResolvedPaint.swift b/Sources/OpenSwiftUICore/Graphic/ResolvedPaint.swift
new file mode 100644
index 00000000..5c3b1629
--- /dev/null
+++ b/Sources/OpenSwiftUICore/Graphic/ResolvedPaint.swift
@@ -0,0 +1,15 @@
+//
+//  ResolvedPaint.swift
+//  OpenSwiftUICore
+//
+//  Audited for iOS 18.0
+//  Status: TODO
+
+package class AnyResolvedPaint: Equatable {
+    package static func == (lhs: AnyResolvedPaint, rhs: AnyResolvedPaint) -> Bool {
+        fatalError("TODO")
+    }
+}
+
+// FIXME
+extension AnyResolvedPaint: @unchecked Sendable {}
diff --git a/Sources/OpenSwiftUICore/Modifier/ViewModifier/ViewInputsModifier.swift b/Sources/OpenSwiftUICore/Modifier/ViewModifier/ViewInputsModifier.swift
new file mode 100644
index 00000000..ccd6e8a2
--- /dev/null
+++ b/Sources/OpenSwiftUICore/Modifier/ViewModifier/ViewInputsModifier.swift
@@ -0,0 +1,11 @@
+//
+//  ViewInputsModifier.swift
+//  OpenSwiftUICore
+//
+//  Audited for iOS 18.0
+//  Status: WIP
+
+package protocol ViewInputsModifier: ViewModifier where Body == Never {
+    static var graphInputsSemantics: Semantics? { get }
+    nonisolated static func _makeViewInputs(modifier: _GraphValue<Self>, inputs: inout _ViewInputs)
+}
diff --git a/Sources/OpenSwiftUICore/Render/GraphicsContext.swift b/Sources/OpenSwiftUICore/Render/GraphicsContext.swift
deleted file mode 100644
index c1f26e2b..00000000
--- a/Sources/OpenSwiftUICore/Render/GraphicsContext.swift
+++ /dev/null
@@ -1,16 +0,0 @@
-//
-//  GraphicsContext.swift
-//  OpenSwiftUICore
-//
-//  Audited for iOS 18.0
-//  Status: WIP
-
-@frozen
-public struct GraphicsContext {
-    @usableFromInline
-    final class Storage {
-        
-    }
-    
-    var storage: Storage
-}
diff --git a/Sources/OpenSwiftUICore/Shape/ForegroundStyle.swift b/Sources/OpenSwiftUICore/Shape/ForegroundStyle.swift
deleted file mode 100644
index 100f7b09..00000000
--- a/Sources/OpenSwiftUICore/Shape/ForegroundStyle.swift
+++ /dev/null
@@ -1,29 +0,0 @@
-@frozen
-public struct ForegroundStyle: ShapeStyle {
-    @inlinable
-    public init() {}
-    
-    public static func _makeView<S>(view: _GraphValue<_ShapeView<S, ForegroundStyle>>, inputs: _ViewInputs) -> _ViewOutputs where S: Shape {
-        fatalError("TODO")
-    }
-}
-
-#if OPENSWIFTUI_SUPPORT_2021_API
-
-extension ForegroundStyle {
-    public func _apply(to shape: inout _ShapeStyle_Shape) {
-        fatalError("TODO")
-    }
-    
-    public static func _apply(to type: inout _ShapeStyle_ShapeType) {
-        fatalError("TODO")
-    }
-}
-
-extension ShapeStyle where Self == ForegroundStyle {
-    @_alwaysEmitIntoClient
-    public static var foreground: ForegroundStyle {
-        .init()
-    }
-}
-#endif
diff --git a/Sources/OpenSwiftUICore/Shape/RoundedCornerStyle.swift b/Sources/OpenSwiftUICore/Shape/RoundedCornerStyle.swift
index 6b4c8fdd..b22d661e 100644
--- a/Sources/OpenSwiftUICore/Shape/RoundedCornerStyle.swift
+++ b/Sources/OpenSwiftUICore/Shape/RoundedCornerStyle.swift
@@ -1,8 +1,8 @@
 //
-//  ShapeRole.swift
-//  OpenSwiftUI
+//  RoundedCornerStyle.swift
+//  OpenSwiftUICore
 //
-//  Audited for iOS 15.5
+//  Audited for iOS 18.0
 //  Status: Complete
 
 /// Defines the shape of a rounded rectangle's corners.
@@ -13,6 +13,3 @@ public enum RoundedCornerStyle: Sendable {
     /// Continuous curvature rounded rect corners.
     case continuous
 }
-
-extension RoundedCornerStyle: Equatable {}
-extension RoundedCornerStyle: Hashable {}
diff --git a/Sources/OpenSwiftUICore/Shape/ShapeRole.swift b/Sources/OpenSwiftUICore/Shape/ShapeRole.swift
index e58c8973..7c20b2c9 100644
--- a/Sources/OpenSwiftUICore/Shape/ShapeRole.swift
+++ b/Sources/OpenSwiftUICore/Shape/ShapeRole.swift
@@ -1,27 +1,20 @@
 //
 //  ShapeRole.swift
-//  OpenSwiftUI
+//  OpenSwiftUICore
 //
-//  Audited for iOS 15.5
+//  Audited for iOS 18.0
 //  Status: Complete
 
-#if OPENSWIFTUI_SUPPORT_2021_API
-
 /// Ways of styling a shape.
 public enum ShapeRole: Sendable {
-    /// Indicates to the shape's style that SwiftUI fills the shape.
+    /// Indicates to the shape's style that OpenSwiftUI fills the shape.
     case fill
     
-    /// Indicates to the shape's style that SwiftUI applies a stroke to
+    /// Indicates to the shape's style that OpenSwiftUI applies a stroke to
     /// the shape's path.
     case stroke
     
-    /// Indicates to the shape's style that SwiftUI uses the shape as a
+    /// Indicates to the shape's style that OpenSwiftUI uses the shape as a
     /// separator.
     case separator
 }
-
-extension ShapeRole: Equatable {}
-extension ShapeRole: Hashable {}
-
-#endif
diff --git a/Sources/OpenSwiftUICore/Shape/ShapeStyle/AnyShapeStyle.swift b/Sources/OpenSwiftUICore/Shape/ShapeStyle/AnyShapeStyle.swift
index 049fb138..02fe190d 100644
--- a/Sources/OpenSwiftUICore/Shape/ShapeStyle/AnyShapeStyle.swift
+++ b/Sources/OpenSwiftUICore/Shape/ShapeStyle/AnyShapeStyle.swift
@@ -1,10 +1,11 @@
 //
 //  AnyShapeStyle.swift
-//  OpenSwiftUI
+//  OpenSwiftUICore
 //
-//  Audited for iOS 15.5
+//  Audited for iOS 18.0
 //  Status: Complete
-//  ID: ABC85937500395B09974756E9F651929
+//  ID: ABC85937500395B09974756E9F651929 (SwiftUI)
+//  ID: C5308685324599C90E2F7A588812BB29 (SwiftUICore)
 
 import Foundation
 import OpenGraphShims
@@ -42,11 +43,11 @@ public struct AnyShapeStyle: ShapeStyle {
         type.result = .none
     }
     
-    #if OPENSWIFTUI_SUPPORT_2023_API
     public typealias Resolved = Never
-    #endif
 }
 
+extension AnyShapeStyle.Storage: @unchecked Sendable {}
+
 /// Abstract base class for type-erased ShapeStyle storage.
 @usableFromInline
 package class AnyShapeStyleBox {
@@ -54,7 +55,9 @@ package class AnyShapeStyleBox {
     package func isEqual(to other: AnyShapeStyleBox) -> Bool { false }
 }
 
-// ID: ABC85937500395B09974756E9F651929
+@available(*, unavailable)
+extension AnyShapeStyleBox: Sendable {}
+
 private final class ShapeStyleBox<S>: AnyShapeStyleBox where S: ShapeStyle {
     let base: S
     
diff --git a/Sources/OpenSwiftUICore/Shape/ShapeStyle/BackgroundStyle.swift b/Sources/OpenSwiftUICore/Shape/ShapeStyle/BackgroundStyle.swift
new file mode 100644
index 00000000..e7385ca6
--- /dev/null
+++ b/Sources/OpenSwiftUICore/Shape/ShapeStyle/BackgroundStyle.swift
@@ -0,0 +1,55 @@
+//
+//  BackgroundStyle.swift
+//  OpenSwiftUICore
+//
+//  Audited for iOS 18.0
+//  Status: WIP
+//  ID: C7D4771CFE453D905E7BCD5A907D32EB (SwiftUICore)
+
+extension ShapeStyle where Self == BackgroundStyle {
+    /// The background style in the current context.
+    ///
+    /// Access this value to get the style OpenSwiftUI uses for the background
+    /// in the current context. The specific color that OpenSwiftUI renders depends
+    /// on factors like the platform and whether the user has turned on Dark
+    /// Mode.
+    ///
+    /// For information about how to use shape styles, see ``ShapeStyle``.
+    @_alwaysEmitIntoClient
+    public static var background: BackgroundStyle {
+        .init()
+    }
+}
+
+@frozen
+public struct BackgroundStyle: ShapeStyle {
+    static let shared = AnyShapeStyle(BackgroundStyle())
+    
+    @inlinable
+    public init() {}
+    
+    // TODO
+}
+
+// MARK: - BackgroundStyleKey
+
+private struct BackgroundStyleKey: EnvironmentKey {
+    static let defaultValue: AnyShapeStyle? = nil
+}
+
+// MARK: - EnvironmentValues + ForegroundStyle
+
+extension EnvironmentValues {
+    package var backgroundStyle: AnyShapeStyle? {
+        get { self[BackgroundStyleKey.self] }
+        set { self[BackgroundStyleKey.self] = newValue }
+    }
+    
+    package var currentBackgroundStyle: AnyShapeStyle? {
+        backgroundStyle
+    }
+    
+    package var effectiveBackgroundStyle: AnyShapeStyle {
+        currentBackgroundStyle ?? BackgroundStyle.shared
+    }
+}
diff --git a/Sources/OpenSwiftUICore/Shape/ShapeStyle/BlendMode.swift b/Sources/OpenSwiftUICore/Shape/ShapeStyle/BlendMode.swift
new file mode 100644
index 00000000..4d8799b5
--- /dev/null
+++ b/Sources/OpenSwiftUICore/Shape/ShapeStyle/BlendMode.swift
@@ -0,0 +1,137 @@
+//
+//  BlendMode.swift
+//  OpenSwiftUICore
+//
+//  Audited for iOS 18.0
+//  Status: WIP
+
+// MARK: - BlendMode
+
+/// Modes for compositing a view with overlapping content.
+public enum BlendMode: Sendable {
+    case normal
+    case multiply
+    case screen
+    case overlay
+    case darken
+    case lighten
+    case colorDodge
+    case colorBurn
+    case softLight
+    case hardLight
+    case difference
+    case exclusion
+    case hue
+    case saturation
+    case color
+    case luminosity
+    case sourceAtop
+    case destinationOver
+    case destinationOut
+    case plusDarker
+    case plusLighter
+}
+
+#if canImport(CoreGraphics)
+package import CoreGraphics
+
+extension BlendMode {
+    package init(_ blendMode: CGBlendMode) {
+        self = switch blendMode {
+            case .normal: .normal
+            case .multiply: .multiply
+            case .screen: .screen
+            case .overlay: .overlay
+            case .darken: .darken
+            case .lighten: .lighten
+            case .colorDodge: .colorDodge
+            case .colorBurn: .colorBurn
+            case .softLight: .softLight
+            case .hardLight: .hardLight
+            case .difference: .difference
+            case .exclusion: .exclusion
+            case .hue: .hue
+            case .saturation: .saturation
+            case .color: .color
+            case .luminosity: .luminosity
+            case .sourceAtop: .sourceAtop
+            case .destinationOver: .destinationOver
+            case .destinationOut: .destinationOut
+            case .plusDarker: .plusDarker
+            case .plusLighter: .plusLighter
+            default: .normal
+        }
+    }
+}
+#endif
+
+extension ShapeStyle {
+    /// Returns a new style based on `self` that applies the specified
+    /// blend mode when drawing.
+    @inlinable
+    public func blendMode(_ mode: BlendMode) -> some ShapeStyle {
+        _BlendModeShapeStyle(style: self, blendMode: mode)
+    }
+}
+
+extension ShapeStyle where Self == AnyShapeStyle {
+    /// Returns a new style based on the current style that uses
+    /// `mode` as its blend mode when drawing.
+    ///
+    /// In most contexts the current style is the foreground but e.g.
+    /// when setting the value of the background style, that becomes
+    /// the current implicit style.
+    ///
+    /// For example, a circle filled with the current foreground
+    /// style and the overlay blend mode:
+    ///
+    ///     Circle().fill(.blendMode(.overlay))
+    ///
+    @_alwaysEmitIntoClient
+    public static func blendMode(_ mode: BlendMode) -> some ShapeStyle {
+        _BlendModeShapeStyle(
+            style: _ImplicitShapeStyle(),
+            blendMode: mode
+        )
+    }
+}
+
+@frozen
+public struct _BlendModeShapeStyle<Style>: ShapeStyle, PrimitiveShapeStyle where Style: ShapeStyle {
+    public var style: Style
+    public var blendMode: BlendMode
+    @inlinable public init(style: Style, blendMode: BlendMode) {
+        self.style = style
+        self.blendMode = blendMode
+    }
+    
+    public func _apply(to shape: inout _ShapeStyle_Shape) {
+        switch shape.operation {
+            case .fallbackColor, .modifyBackground:
+                style._apply(to: &shape)
+            case .prepareText:
+                if blendMode == .normal {
+                    style._apply(to: &shape)
+                } else {
+                    shape.result = .preparedText(.foregroundKeyColor)
+                }
+            default:
+                fatalError("TODO")
+//            case resolveStyle(name: _ShapeStyle_Name, levels: Range<Int>):
+//                
+//                
+//            case .multiLevel:
+//                <#code#>
+//            case .copyStyle(let name):
+//                <#code#>
+//            case .primaryStyle:
+//                <#code#>
+        }
+    }
+    
+    public static func _apply(to type: inout _ShapeStyle_ShapeType) {
+        Style._apply(to: &type)
+    }
+    
+    public typealias Resolved = Never
+}
diff --git a/Sources/OpenSwiftUICore/Shape/ShapeStyle/ContentStyle.swift b/Sources/OpenSwiftUICore/Shape/ShapeStyle/ContentStyle.swift
new file mode 100644
index 00000000..d1e131a6
--- /dev/null
+++ b/Sources/OpenSwiftUICore/Shape/ShapeStyle/ContentStyle.swift
@@ -0,0 +1,49 @@
+//
+//  ContentStyle.swift
+//  OpenSwiftUICore
+//
+//  Audited for iOS 18.0
+//  Status: Blocked by Material
+
+import Foundation
+
+package enum ContentStyle {
+    package enum ID: Swift.Int8 {
+        case primary
+        case secondary
+        case tertiary
+        case quaternary
+        case quinary
+    }
+    
+    package enum Primitive {
+        case fill
+        case stroke
+        case separator
+        package init(_ role: ShapeRole) {
+            switch role {
+            case .fill: self = .fill
+            case .stroke: self = .stroke
+            case .separator: self = .separator
+            }
+        }
+    }
+    
+    package struct Style: Hashable {
+        package var id: ID
+        package var primitive: Primitive
+        package init(id: ID, primitive: Primitive) {
+            self.id = id
+            self.primitive = primitive
+        }
+    }
+    
+//    package struct MaterialStyle: Hashable {
+//        package var material: Material.ResolvedMaterial
+//        package var base: Style
+//        package init(material: Material.ResolvedMaterial, base: Style) {
+//            self.material = material
+//            self.base = base
+//        }
+//    }
+}
diff --git a/Sources/OpenSwiftUICore/Shape/ShapeStyle/ForegroundStyle.swift b/Sources/OpenSwiftUICore/Shape/ShapeStyle/ForegroundStyle.swift
new file mode 100644
index 00000000..15c66ea6
--- /dev/null
+++ b/Sources/OpenSwiftUICore/Shape/ShapeStyle/ForegroundStyle.swift
@@ -0,0 +1,85 @@
+//
+//  ForegroundStyle.swift
+//  OpenSwiftUICore
+//
+//  Audited for iOS 18.0
+//  Status: Complete
+//  ID: BEFE9363F68E039B4AB6422B8AA4535A (SwiftUICore)
+
+// MARK: - ForegroundStyleKey
+
+private struct ForegroundStyleKey: EnvironmentKey {
+    static let defaultValue: AnyShapeStyle? = nil
+}
+
+// MARK: - DefaultForegroundStyleKey
+
+private struct DefaultForegroundStyleKey: EnvironmentKey {
+    static let defaultValue: AnyShapeStyle? = nil
+}
+
+// MARK: - EnvironmentValues + ForegroundStyle
+
+extension EnvironmentValues {
+    package var foregroundStyle: AnyShapeStyle? {
+        get { self[ForegroundStyleKey.self] }
+        set { self[ForegroundStyleKey.self] = newValue }
+    }
+    
+    package var defaultForegroundStyle: AnyShapeStyle? {
+        get { self[DefaultForegroundStyleKey.self] }
+        set { self[DefaultForegroundStyleKey.self] = newValue }
+    }
+    
+    package var currentForegroundStyle: AnyShapeStyle? {
+        foregroundStyle ?? defaultForegroundStyle
+    }
+    
+    package var _effectiveForegroundStyle: AnyShapeStyle {
+        currentForegroundStyle ?? .init(.foreground)
+    }
+}
+
+extension ShapeStyle where Self == ForegroundStyle {
+    /// The foreground style in the current context.
+    ///
+    /// Access this value to get the style OpenSwiftUI uses for foreground elements,
+    /// like text, symbols, and shapes, in the current context. Use the
+    /// ``View/foregroundStyle(_:)`` modifier to set a new foreground style for
+    /// a given view and its child views.
+    ///
+    /// For information about how to use shape styles, see ``ShapeStyle``.
+    @_alwaysEmitIntoClient
+    public static var foreground: ForegroundStyle {
+        .init()
+    }
+}
+
+/// The foreground style in the current context.
+///
+/// You can also use ``ShapeStyle/foreground`` to construct this style.
+@frozen
+public struct ForegroundStyle: ShapeStyle, PrimitiveShapeStyle {
+    /// Creates a foreground style instance.
+    @inlinable
+    public init() {}
+    
+    nonisolated public static func _makeView<S>(view: _GraphValue<_ShapeView<S, ForegroundStyle>>, inputs: _ViewInputs) -> _ViewOutputs where S: Shape {
+        legacyMakeShapeView(view: view, inputs: inputs)
+    }
+}
+
+extension ForegroundStyle {
+    public func _apply(to shape: inout _ShapeStyle_Shape) {
+        if shape.activeRecursiveStyles.contains(.foreground) {
+            LegacyContentStyle.sharedPrimary._apply(to: &shape)
+        } else {
+            shape.effectiveForegroundStyle._apply(to: &shape)
+            shape.activeRecursiveStyles.subtract(.foreground)
+        }
+    }
+    
+    public static func _apply(to type: inout _ShapeStyle_ShapeType) {
+        type.result = .bool(true)
+    }
+}
diff --git a/Sources/OpenSwiftUICore/Shape/ShapeStyle/ForegroundStyleModifier.swift b/Sources/OpenSwiftUICore/Shape/ShapeStyle/ForegroundStyleModifier.swift
new file mode 100644
index 00000000..14ca29c3
--- /dev/null
+++ b/Sources/OpenSwiftUICore/Shape/ShapeStyle/ForegroundStyleModifier.swift
@@ -0,0 +1,250 @@
+//
+//  ForegroundStyleModifier.swift
+//  OpenSwiftUICore
+//
+//  Audited for iOS 18.0
+//  Status: WIP
+
+// MARK: - View + foregroundStyle
+
+extension View {
+    /// Sets a view's foreground elements to use a given style.
+    ///
+    /// Use this method to style
+    /// foreground content like text, shapes, and template images
+    /// (including symbols):
+    ///
+    ///     HStack {
+    ///         Image(systemName: "triangle.fill")
+    ///         Text("Hello, world!")
+    ///         RoundedRectangle(cornerRadius: 5)
+    ///             .frame(width: 40, height: 20)
+    ///     }
+    ///     .foregroundStyle(.teal)
+    ///
+    /// The example above creates a row of ``ShapeStyle/teal`` foreground
+    /// elements:
+    ///
+    /// ![A screenshot of a teal triangle, string, and rounded
+    /// rectangle.](View-foregroundStyle-1)
+    ///
+    /// You can use any style that conforms to the ``ShapeStyle`` protocol,
+    /// like the ``ShapeStyle/teal`` color in the example above, or the
+    /// ``ShapeStyle/linearGradient(colors:startPoint:endPoint:)`` gradient
+    /// shown below:
+    ///
+    ///     Text("Gradient Text")
+    ///         .font(.largeTitle)
+    ///         .foregroundStyle(
+    ///             .linearGradient(
+    ///                 colors: [.yellow, .blue],
+    ///                 startPoint: .top,
+    ///                 endPoint: .bottom
+    ///             )
+    ///         )
+    ///
+    /// ![A screenshot of the words Gradient Text, with letters that
+    ///   appear yellow at the top, and transition to blue
+    ///   toward the bottom.](View-foregroundStyle-2)
+    ///
+    /// > Tip: If you want to fill a single ``Shape`` instance with a style,
+    /// use the ``Shape/fill(style:)`` shape modifier instead because it's more
+    /// efficient.
+    ///
+    /// OpenSwiftUI creates a context-dependent render for a given style.
+    /// For example, a ``Color`` that you load from an asset catalog
+    /// can have different light and dark appearances, while some styles
+    /// also vary by platform.
+    ///
+    /// Hierarchical foreground styles like ``ShapeStyle/secondary``
+    /// don't impose a style of their own, but instead modify other styles.
+    /// In particular, they modify the primary
+    /// level of the current foreground style to the degree given by
+    /// the hierarchical style's name.
+    /// To find the current foreground style to modify, OpenSwiftUI looks for
+    /// the innermost containing style that you apply with the
+    /// `foregroundStyle(_:)` or the ``View/foregroundColor(_:)`` modifier.
+    /// If you haven't specified a style, OpenSwiftUI uses the default foreground
+    /// style, as in the following example:
+    ///
+    ///     VStack(alignment: .leading) {
+    ///         Label("Primary", systemImage: "1.square.fill")
+    ///         Label("Secondary", systemImage: "2.square.fill")
+    ///             .foregroundStyle(.secondary)
+    ///     }
+    ///
+    /// ![A screenshot of two labels with the text primary and secondary.
+    /// The first appears in a brighter shade than the
+    /// second, both in a grayscale color.](View-foregroundStyle-3)
+    ///
+    /// If you add a foreground style on the enclosing
+    /// ``VStack``, the hierarchical styling responds accordingly:
+    ///
+    ///     VStack(alignment: .leading) {
+    ///         Label("Primary", systemImage: "1.square.fill")
+    ///         Label("Secondary", systemImage: "2.square.fill")
+    ///             .foregroundStyle(.secondary)
+    ///     }
+    ///     .foregroundStyle(.blue)
+    ///
+    /// ![A screenshot of two labels with the text primary and secondary.
+    /// The first appears in a brighter shade than the
+    /// second, both tinted blue.](View-foregroundStyle-4)
+    ///
+    /// When you apply a custom style to a view, the view disables the vibrancy
+    /// effect for foreground elements in that view, or in any of its child
+    /// views, that it would otherwise gain from adding a background material
+    /// --- for example, using the ``View/background(_:ignoresSafeAreaEdges:)``
+    /// modifier. However, hierarchical styles applied to the default foreground
+    /// don't disable vibrancy.
+    ///
+    /// - Parameter style: The color or pattern to use when filling in the
+    ///   foreground elements. To indicate a specific value, use ``Color`` or
+    ///   ``ShapeStyle/image(_:sourceRect:scale:)``, or one of the gradient
+    ///   types, like
+    ///   ``ShapeStyle/linearGradient(colors:startPoint:endPoint:)``. To set a
+    ///   style that’s relative to the containing view's style, use one of the
+    ///   semantic styles, like ``ShapeStyle/primary``.
+    ///
+    /// - Returns: A view that uses the given foreground style.
+    @inlinable
+    nonisolated public func foregroundStyle<S>(_ style: S) -> some View where S: ShapeStyle {
+        modifier(_ForegroundStyleModifier(style: style))
+    }
+
+    /// Sets the primary and secondary levels of the foreground
+    /// style in the child view.
+    ///
+    /// OpenSwiftUI uses these styles when rendering child views
+    /// that don't have an explicit rendering style, like images,
+    /// text, shapes, and so on.
+    ///
+    /// Symbol images within the view hierarchy use the
+    /// ``SymbolRenderingMode/palette`` rendering mode when you apply this
+    /// modifier, if you don't explicitly specify another mode.
+    ///
+    /// - Parameters:
+    ///   - primary: The primary color or pattern to use when filling in
+    ///     the foreground elements. To indicate a specific value, use ``Color``
+    ///     or ``ShapeStyle/image(_:sourceRect:scale:)``, or one of the gradient
+    ///     types, like
+    ///     ``ShapeStyle/linearGradient(colors:startPoint:endPoint:)``. To set a
+    ///     style that’s relative to the containing view's style, use one of the
+    ///     semantic styles, like ``ShapeStyle/primary``.
+    ///   - secondary: The secondary color or pattern to use when
+    ///     filling in the foreground elements.
+    ///
+    /// - Returns: A view that uses the given foreground styles.
+    @inlinable
+    nonisolated public func foregroundStyle<S1, S2>(_ primary: S1, _ secondary: S2) -> some View where S1: ShapeStyle, S2: ShapeStyle {
+        modifier(_ForegroundStyleModifier2(primary: primary, secondary: secondary))
+    }
+    
+    /// Sets the primary, secondary, and tertiary levels of
+    /// the foreground style.
+    ///
+    /// OpenSwiftUI uses these styles when rendering child views
+    /// that don't have an explicit rendering style, like images,
+    /// text, shapes, and so on.
+    ///
+    /// Symbol images within the view hierarchy use the
+    /// ``SymbolRenderingMode/palette`` rendering mode when you apply this
+    /// modifier, if you don't explicitly specify another mode.
+    ///
+    /// - Parameters:
+    ///   - primary: The primary color or pattern to use when filling in
+    ///     the foreground elements. To indicate a specific value, use ``Color``
+    ///     or ``ShapeStyle/image(_:sourceRect:scale:)``, or one of the gradient
+    ///     types, like
+    ///     ``ShapeStyle/linearGradient(colors:startPoint:endPoint:)``. To set a
+    ///     style that’s relative to the containing view's style, use one of the
+    ///     semantic styles, like ``ShapeStyle/primary``.
+    ///   - secondary: The secondary color or pattern to use when
+    ///     filling in the foreground elements.
+    ///   - tertiary: The tertiary color or pattern to use when
+    ///     filling in the foreground elements.
+    ///
+    /// - Returns: A view that uses the given foreground styles.
+    @inlinable
+    nonisolated public func foregroundStyle<S1, S2, S3>(_ primary: S1, _ secondary: S2, _ tertiary: S3) -> some View where S1: ShapeStyle, S2: ShapeStyle, S3: ShapeStyle {
+        modifier(_ForegroundStyleModifier3(primary: primary, secondary: secondary, tertiary: tertiary))
+    }
+}
+
+// MARK: - _ForegroundStyleModifier
+
+@frozen
+@MainActor
+@preconcurrency
+public struct _ForegroundStyleModifier<Style>: PrimitiveViewModifier, ViewInputsModifier where Style: ShapeStyle {
+    nonisolated package static var graphInputsSemantics: Semantics? { .v4 }
+    
+    public var style: Style
+    
+    @inlinable
+    nonisolated public init(style: Style) {
+        self.style = style
+    }
+    
+    public nonisolated static func _makeViewInputs(modifier: _GraphValue<_ForegroundStyleModifier<Style>>, inputs: inout _ViewInputs) {
+        fatalError("TODO")
+    }
+    
+    public typealias Body = Never
+}
+
+@available(*, unavailable)
+extension _ForegroundStyleModifier: Sendable {}
+
+// MARK: - _ForegroundStyleModifier2
+
+@frozen @MainActor @preconcurrency public struct _ForegroundStyleModifier2<S1, S2>: PrimitiveViewModifier, ViewInputsModifier where S1: ShapeStyle, S2: ShapeStyle {
+    nonisolated package static var graphInputsSemantics: Semantics? { .v4 }
+    
+    public var primary: S1
+    public var secondary: S2
+    
+    @inlinable
+    nonisolated public init(primary: S1, secondary: S2) {
+        self.primary = primary
+        self.secondary = secondary
+    }
+
+    nonisolated public static func _makeViewInputs(modifier: _GraphValue<_ForegroundStyleModifier2<S1, S2>>, inputs: inout _ViewInputs) {
+        fatalError("TODO")
+    }
+
+    public typealias Body = Never
+}
+
+@available(*, unavailable)
+extension _ForegroundStyleModifier2: Sendable {}
+
+// MARK: - _ForegroundStyleModifier3
+
+@frozen
+@MainActor
+@preconcurrency
+public struct _ForegroundStyleModifier3<S1, S2, S3>: PrimitiveViewModifier, ViewInputsModifier where S1: ShapeStyle, S2: ShapeStyle, S3: ShapeStyle {
+    nonisolated package static var graphInputsSemantics: Semantics? { .v4 }
+
+    public var primary: S1
+    public var secondary: S2
+    public var tertiary: S3
+    @inlinable
+    nonisolated public init(primary: S1, secondary: S2, tertiary: S3) {
+        self.primary = primary
+        self.secondary = secondary
+        self.tertiary = tertiary
+    }
+
+    nonisolated public static func _makeViewInputs(modifier: _GraphValue<_ForegroundStyleModifier3<S1, S2, S3>>, inputs: inout _ViewInputs) {
+        fatalError("TODO")
+    }
+
+    @available(iOS 15.0, tvOS 15.0, watchOS 8.0, macOS 12.0, *)
+    public typealias Body = Never
+}
+
+@available(*, unavailable)
+extension _ForegroundStyleModifier3: Sendable {}
diff --git a/Sources/OpenSwiftUICore/Shape/ShapeStyle/HierarchicalShapeStyle.swift b/Sources/OpenSwiftUICore/Shape/ShapeStyle/HierarchicalShapeStyle.swift
new file mode 100644
index 00000000..f9fff1ee
--- /dev/null
+++ b/Sources/OpenSwiftUICore/Shape/ShapeStyle/HierarchicalShapeStyle.swift
@@ -0,0 +1,85 @@
+//
+//  HierarchicalShapeStyle.swift
+//  OpenSwiftUICore
+//
+//  Audited for iOS 18.0
+//  Status: Blocked by SeparatorShapeStyle and BackgroundMaterial
+
+/// A shape style that maps to one of the numbered content styles.
+@frozen
+public struct HierarchicalShapeStyle: ShapeStyle, PrimitiveShapeStyle {
+    package var id: UInt32
+    package init(id: UInt32) {
+        self.id = id
+    }
+
+    /// A shape style that maps to the first level of the current
+    /// content style.
+    public static let primary: HierarchicalShapeStyle = .init(id: 0)
+
+    /// A shape style that maps to the second level of the current
+    /// content style.
+    public static let secondary: HierarchicalShapeStyle = .init(id: 1)
+
+    /// A shape style that maps to the third level of the current
+    /// content style.
+    public static let tertiary: HierarchicalShapeStyle = .init(id: 2)
+
+    /// A shape style that maps to the fourth level of the current
+    /// content style.
+    public static let quaternary: HierarchicalShapeStyle = .init(id: 3)
+    
+    package static let sharedPrimary: AnyShapeStyle = .init(HierarchicalShapeStyle.primary)
+    
+    package var level: Int {
+        Int(id)
+    }
+    
+    public func _apply(to shape: inout _ShapeStyle_Shape) {
+        if case .primaryStyle = shape.operation {
+            shape.result = .style(HierarchicalShapeStyle.sharedPrimary)
+        } else {
+            if shape.activeRecursiveStyles.contains(.content) {
+                LegacyContentStyle.sharedPrimary._apply(to: &shape)
+            } else {
+                shape.activeRecursiveStyles.formUnion(.content)
+                if let foregroundStyle = shape.foregroundStyle ?? shape.currentForegroundStyle {
+                    let style = foregroundStyle.primaryStyle(in: shape.environment) ?? foregroundStyle
+                    if id == 0 {
+                        if case .copyStyle = shape.operation {
+                            shape.result = .style(style)
+                        } else {
+                            style._apply(to: &shape)
+                        }
+                    } else {
+                        if case .copyStyle = shape.operation {
+                            shape.result = .style(AnyShapeStyle(OffsetShapeStyle(base: style, offset: level)))
+                        } else {
+                            OffsetShapeStyle(base: style, offset: level)._apply(to: &shape)
+                        }
+                    }
+                } else {
+                    switch shape.role {
+                        case .separator:
+                            // SeparatorShapeStyle._apply(to: shape)
+                            break
+                        default:
+                            // shape.environment.backgroundMaterial
+                            break
+                    }
+                }
+                shape.activeRecursiveStyles.subtract(.content)
+            }
+        }
+    }
+    
+    public static func _apply(to type: inout _ShapeStyle_ShapeType) {
+        type.result = .bool(true)
+    }
+}
+
+extension HierarchicalShapeStyle {
+    /// A shape style that maps to the fifth level of the current
+    /// content style.
+    public static let quinary: HierarchicalShapeStyle = .init(id: 4)
+}
diff --git a/Sources/OpenSwiftUICore/Shape/ShapeStyle/ImplicitShapeStyle.swift b/Sources/OpenSwiftUICore/Shape/ShapeStyle/ImplicitShapeStyle.swift
new file mode 100644
index 00000000..94fc033f
--- /dev/null
+++ b/Sources/OpenSwiftUICore/Shape/ShapeStyle/ImplicitShapeStyle.swift
@@ -0,0 +1,25 @@
+//
+//  ImplicitShapeStyle.swift
+//  OpenSwiftUICore
+//
+//  Audited for iOS 18.0
+//  Status: Complete
+
+/// A shape style representing the implicit base of style modifiers.
+@frozen
+public struct _ImplicitShapeStyle: ShapeStyle, PrimitiveShapeStyle {
+    @inlinable
+    init() {}
+    
+    public func _apply(to shape: inout _ShapeStyle_Shape) {
+        guard case let .copyStyle(name) = shape.operation else {
+            ForegroundStyle()._apply(to: &shape)
+            return
+        }
+        let style = switch name {
+            case .background: shape.environment.effectiveBackgroundStyle
+            default: shape.effectiveForegroundStyle
+        }
+        shape.result = .style(style)
+    }
+}
diff --git a/Sources/OpenSwiftUICore/Shape/ShapeStyle/LegacyContentStyle.swift b/Sources/OpenSwiftUICore/Shape/ShapeStyle/LegacyContentStyle.swift
new file mode 100644
index 00000000..6aa94179
--- /dev/null
+++ b/Sources/OpenSwiftUICore/Shape/ShapeStyle/LegacyContentStyle.swift
@@ -0,0 +1,20 @@
+//
+//  LegacyContentStyle.swift
+//  OpenSwiftUICore
+//
+//  Audited for iOS 18.0
+//  Status: WIP
+
+package struct LegacyContentStyle: ShapeStyle, PrimitiveShapeStyle {
+    package static let sharedPrimary: AnyShapeStyle = {
+        // Blocked by Color
+        fatalError("TODO")
+    }()
+    
+    package var id: ContentStyle.ID
+    package var color: Color
+    
+    package func _apply(to shape: inout _ShapeStyle_Shape) {
+        fatalError("TODO")
+    }
+}
diff --git a/Sources/OpenSwiftUICore/Shape/ShapeStyle/OffsetShapeStyle.swift b/Sources/OpenSwiftUICore/Shape/ShapeStyle/OffsetShapeStyle.swift
new file mode 100644
index 00000000..4ec432e2
--- /dev/null
+++ b/Sources/OpenSwiftUICore/Shape/ShapeStyle/OffsetShapeStyle.swift
@@ -0,0 +1,48 @@
+//
+//  OffsetShapeStyle.swift
+//  OpenSwiftUICore
+//
+//  Audited for iOS 18.0
+//  Status: Blocked by _ShapeStyle_Pack
+
+package struct OffsetShapeStyle<Base>: ShapeStyle where Base: ShapeStyle {
+    package var base: Base
+    package var offset: Int
+    
+    package func _apply(to shape: inout _ShapeStyle_Shape) {
+        switch shape.operation {
+            case .prepareText(let level):
+                shape.operation = .prepareText(level: offset + level)
+                base._apply(to: &shape)
+            case let .resolveStyle(_, levels):
+                let _ = levels.lowerBound + offset ..< levels.upperBound + offset
+                // Blocked by _ShapeStyle_Pack
+            case .multiLevel:
+                shape.result = .bool(false)
+            case .fallbackColor(let level):
+                shape.operation = .fallbackColor(level: offset + level)
+                base._apply(to: &shape)
+            case .copyStyle:
+                base.mapCopiedStyle(in: &shape) { style in
+                    style.offset(by: offset)
+                }
+            case .primaryStyle:
+                shape.result = .style(AnyShapeStyle(base))
+            case .modifyBackground(let level):
+                shape.operation = .modifyBackground(level: offset + level)
+                base._apply(to: &shape)
+        }
+    }
+    
+    package static func _apply(to type: inout _ShapeStyle_ShapeType) {
+        Base._apply(to: &type)
+    }
+    
+    package typealias Resolved = Never
+}
+
+extension ShapeStyle {
+    package func offset(by levels: Int) -> OffsetShapeStyle<Self> {
+        OffsetShapeStyle(base: self, offset: levels)
+    }
+}
diff --git a/Sources/OpenSwiftUICore/Shape/ShapeStyle/ShapeStyle.swift b/Sources/OpenSwiftUICore/Shape/ShapeStyle/ShapeStyle.swift
index 5e4c5482..b91636da 100644
--- a/Sources/OpenSwiftUICore/Shape/ShapeStyle/ShapeStyle.swift
+++ b/Sources/OpenSwiftUICore/Shape/ShapeStyle/ShapeStyle.swift
@@ -1,13 +1,12 @@
 //
-//  AnyShapeStyle.swift
-//  OpenSwiftUI
+//  ShapeStyle.swift
+//  OpenSwiftUICore
 //
-//  Audited for iOS 15.5
-//  Status: Blocked by _ShapeStyle_Shape
+//  Audited for iOS 18.0
+//  Status: Blocked by Graident and Material
 
-import Foundation
+// MARK: - ShapeStyle
 
-#if OPENSWIFTUI_RELEASE_2024
 /// A color or pattern to use when rendering a shape.
 ///
 /// You create custom shape styles by declaring a type that conforms to the
@@ -89,10 +88,10 @@ import Foundation
 ///
 ///     ![A screenshot of a title in the primary content color above a
 ///     subtitle in the secondary content color.](ShapeStyle-3)
-public protocol ShapeStyle {
+public protocol ShapeStyle: Sendable {
     /// Returns the view's outputs, for the shape view and its inputs.
     @available(*, deprecated, message: "obsolete")
-    static func _makeView<S>(view: _GraphValue<_ShapeView<S, Self>>, inputs: _ViewInputs) -> _ViewOutputs where S : Shape
+    static func _makeView<S>(view: _GraphValue<_ShapeView<S, Self>>, inputs: _ViewInputs) -> _ViewOutputs where S: Shape
     
     /// Called to apply the style to the given shape value.
     func _apply(to shape: inout _ShapeStyle_Shape)
@@ -111,103 +110,20 @@ public protocol ShapeStyle {
     func resolve(in environment: EnvironmentValues) -> Self.Resolved
 }
 
-extension Never: ShapeStyle {
-    public static func _makeView(view: _GraphValue<Never>, inputs: _ViewInputs) -> _ViewOutputs {
-        fatalError()
-    }
-}
-#elseif OPENSWIFTUI_RELEASE_2021
-/// A color or pattern to use when rendering a shape.
-///
-/// You don't use the `ShapeStyle` protocol directly. Instead, use one of
-/// the concrete styles that OpenSwiftUI defines. To indicate a specific color
-/// or pattern, you can use ``Color`` or the style returned by
-/// ``ShapeStyle/image(_:sourceRect:scale:)``, or one of the gradient
-/// types, like the one returned by
-/// ``ShapeStyle/radialGradient(_:center:startRadius:endRadius:)``.
-/// To set a color that's appropriate for a given context on a given
-/// platform, use one of the semantic styles, like ``ShapeStyle/background`` or
-/// ``ShapeStyle/primary``.
-///
-/// You can use a shape style by:
-/// * Filling a shape with a style with the ``Shape/fill(_:style:)`` modifier:
-///
-///     ```
-///     Path { path in
-///         path.move(to: .zero)
-///         path.addLine(to: CGPoint(x: 50, y: 0))
-///         path.addArc(
-///             center: .zero,
-///             radius: 50,
-///             startAngle: .zero,
-///             endAngle: .degrees(90),
-///             clockwise: false)
-///     }
-///     .fill(.radial(
-///         Gradient(colors: [.yellow, .red]),
-///         center: .topLeading,
-///         startRadius: 15,
-///         endRadius: 80))
-///     ```
-///
-///     ![A screenshot of a quarter of a circle filled with
-///     a radial gradient.](ShapeStyle-1)
-///
-/// * Tracing the outline of a shape with a style with either the
-///   ``Shape/stroke(_:lineWidth:)`` or the ``Shape/stroke(_:style:)`` modifier:
-///
-///     ```
-///     RoundedRectangle(cornerRadius: 10)
-///         .stroke(.mint, lineWidth: 10)
-///         .frame(width: 200, height: 50)
-///     ```
-///
-///     ![A screenshot of a rounded rectangle, outlined in mint.](ShapeStyle-2)
-///
-/// * Styling the foreground elements in a view with the
-///   ``View/foregroundStyle(_:)`` modifier:
-///
-///     ```
-///     VStack(alignment: .leading) {
-///         Text("Primary")
-///             .font(.title)
-///         Text("Secondary")
-///             .font(.caption)
-///             .foregroundStyle(.secondary)
-///     }
-///     ```
-///
-///     ![A screenshot of a title in the primary content color above a
-///     subtitle in the secondary content color.](ShapeStyle-3)
-public protocol ShapeStyle {
-    /// Returns the view's outputs, for the shape view and its inputs.
-    @available(*, deprecated, message: "obsolete")
-    static func _makeView<S>(view: _GraphValue<_ShapeView<S, Self>>, inputs: _ViewInputs) -> _ViewOutputs where S : Shape
-    
-    /// Called to apply the style to the given shape value.
-    func _apply(to shape: inout _ShapeStyle_Shape)
-    
-    /// Called to apply the style to the given shape type.
-    static func _apply(to type: inout _ShapeStyle_ShapeType)
-}
-#endif
+// MARK: - PrimitiveShapeStyle
 
+package protocol PrimitiveShapeStyle: ShapeStyle where Resolved == Never {}
 
-extension ShapeStyle {
-    public static func _makeView<S>(view: _GraphValue<_ShapeView<S, Self>>, inputs: _ViewInputs) -> _ViewOutputs where S: Shape {
-        legacyMakeShapeView(view: view, inputs: inputs)
-    }
+// MARK: - ShapeStyle + Never
+
+extension Never: ShapeStyle {
+    public typealias Resolved = Never
     
-    static func legacyMakeShapeView<S>(view: _GraphValue<_ShapeView<S, Self>>, inputs: _ViewInputs) -> _ViewOutputs where S: Shape {
-        _ShapeView._makeView(view: view, inputs: inputs)
+    public static func _makeView<S>(view: _GraphValue<_ShapeView<S, Never>>, inputs: _ViewInputs) -> _ViewOutputs where S: Shape{
+        fatalError()
     }
-    
-    public func _apply(to shape: inout _ShapeStyle_Shape) {}
-    public static func _apply(to type: inout _ShapeStyle_ShapeType) {}
 }
 
-#if OPENSWIFTUI_RELEASE_2024
-
 extension ShapeStyle where Resolved == Never {
     public func resolve(in: EnvironmentValues) -> Self.Resolved {
         fatalError()
@@ -216,77 +132,83 @@ extension ShapeStyle where Resolved == Never {
     public static func _apply(to type: inout _ShapeStyle_ShapeType) {}
 }
 
-#endif
-
-#if OPENSWIFTUI_RELEASE_2024
+// MARK: - ShapeStyle + Default implementation
 
-// MARK: - _ShapeStyle_Name
-
-package enum _ShapeStyle_Name: UInt8, Equatable, Comparable {
-    case foreground
-    case background
-    case multicolor
+extension ShapeStyle {
+    package typealias Name = _ShapeStyle_Name
+    package typealias Pack = _ShapeStyle_Pack
+    package typealias ResolverMode = _ShapeStyle_ResolverMode
     
-    package static func < (lhs: _ShapeStyle_Name, rhs: _ShapeStyle_Name) -> Bool {
-        lhs.rawValue < rhs.rawValue
+    nonisolated public static func _makeView<S>(view: _GraphValue<_ShapeView<S, Self>>, inputs: _ViewInputs) -> _ViewOutputs where S: Shape {
+        legacyMakeShapeView(view: view, inputs: inputs)
     }
-}
-
-#endif
-
-// MARK: - _ShapeStyle_Shape [TODO]
-
-public struct _ShapeStyle_Shape {
-    enum Operation {
-        case prepare(Text, level: Int)
-        case resolveStyle(levels: Range<Int>)
-        case fallbackColor(level: Int)
-        case multiLevel
-        case copyForeground
-        case primaryStyle
-        case modifyBackground
+    
+    static func legacyMakeShapeView<S>(view: _GraphValue<_ShapeView<S, Self>>, inputs: _ViewInputs) -> _ViewOutputs where S: Shape {
+        _ShapeView._makeView(view: view, inputs: inputs)
     }
     
-    enum Result {
-        case prepared(Text)
-        case resolved(ResolvedStyle)
-        case style(AnyShapeStyle)
-        case color(Color)
-        case bool(Bool)
-        case none
+    public func _apply(to shape: inout _ShapeStyle_Shape) {
+        guard Resolved.self != Never.self else {
+            return
+        }
+        resolve(in: shape.environment)._apply(to: &shape)
     }
     
-    indirect enum ResolvedStyle {
-//        case color(Color.Resolved)
-//        case paint(AnyResolvedPaint)
-//        case foregroundMaterial(Color.Resolved, ContentStyle.MaterialResolved)
-//        case backgroundMaterial(Material.Resolved)
-        case array([ResolvedStyle])
-//        case blend(GraphicsBlendMode, _ShapeStyle_Graphics.ResolvedBlend)
-        case opacity(Float, ResolvedStyle)
-//        case multicolor(ResolvedMulticolorStyle)
+    public static func _apply(to type: inout _ShapeStyle_ShapeType) {
+        guard Resolved.self != Never.self else {
+            return
+        }
+        Resolved._apply(to: &type)
     }
     
-    var operation: Operation
-    var result: Result
-    var environment: EnvironmentValues
-    var bounds: CGRect?
-    var role: ShapeRole
-    var inRecursiveStyle: Bool
-}
+    @_spi(Private)
+    public func fallbackColor(in environment: EnvironmentValues, level: Int = 0) -> Color? {
+        var shape = _ShapeStyle_Shape(operation: .fallbackColor(level: level), environment: environment)
+        _apply(to: &shape)
+        switch shape.result {
+            case let .color(color): return color
+            default: return nil
+        }
+    }
 
-// MARK: - _ShapeStyle_ShapeType
+    // package func resolveBackgroundMaterial(in environment: EnvironmentValues, level: Int = 0) -> Material.ResolvedMaterial?
+    // package func resolveGradient(in environment: EnvironmentValues, level: Int = 0) -> ResolvedGradient?
 
-public struct _ShapeStyle_ShapeType {
-    package var operation: Operation
-    package var result: Result
+    package func copyStyle(name: Name = .foreground, in env: EnvironmentValues, foregroundStyle: AnyShapeStyle? = nil) -> AnyShapeStyle {
+        var shape = _ShapeStyle_Shape(operation: .copyStyle(name: name), environment: env, foregroundStyle: foregroundStyle)
+        _apply(to: &shape)
+        switch shape.result {
+            case let .style(style): return style
+            default: return AnyShapeStyle(self)
+        }
+    }
+    
+    package func mapCopiedStyle<S>(in shape: inout _ShapeStyle_Shape, body: (AnyShapeStyle) -> S) where S: ShapeStyle {
+        guard case .copyStyle = shape.operation else {
+            return
+        }
+        _apply(to: &shape)
+        guard case let .style(style) = shape.result else {
+            return
+        }
+        shape.result = .style(AnyShapeStyle(body(style)))
+    }
     
-    package enum Result {
-        case bool(Bool)
-        case none
+    package func primaryStyle(in env: EnvironmentValues) -> AnyShapeStyle? {
+        var shape = _ShapeStyle_Shape(operation: .primaryStyle, environment: env)
+        _apply(to: &shape)
+        switch shape.result {
+            case let .style(style): return style
+            default: return nil
+        }
     }
     
-    package enum Operation: Hashable {
-        case modifiesBackground
+    package func isMultiLevel(in env: EnvironmentValues) -> Bool {
+        var shape = _ShapeStyle_Shape(operation: .multiLevel, environment: env)
+        _apply(to: &shape)
+        switch shape.result {
+            case let .bool(value): return value
+            default: return false
+        }
     }
 }
diff --git a/Sources/OpenSwiftUICore/Shape/ShapeStyle/ShapeStyleName.swift b/Sources/OpenSwiftUICore/Shape/ShapeStyle/ShapeStyleName.swift
new file mode 100644
index 00000000..ab346c54
--- /dev/null
+++ b/Sources/OpenSwiftUICore/Shape/ShapeStyle/ShapeStyleName.swift
@@ -0,0 +1,16 @@
+//
+//  ShapeStyle_Name.swift
+//  OpenSwiftUICore
+//
+//  Audited for iOS 18.0
+//  Status: Complete
+
+package enum _ShapeStyle_Name: UInt8, Equatable, Comparable {
+    case foreground
+    case background
+    case multicolor
+    
+    package static func < (lhs: _ShapeStyle_Name, rhs: _ShapeStyle_Name) -> Bool {
+        return lhs.rawValue < rhs.rawValue
+    }
+}
diff --git a/Sources/OpenSwiftUICore/Shape/ShapeStyle/ShapeStylePack.swift b/Sources/OpenSwiftUICore/Shape/ShapeStyle/ShapeStylePack.swift
new file mode 100644
index 00000000..44913ae8
--- /dev/null
+++ b/Sources/OpenSwiftUICore/Shape/ShapeStyle/ShapeStylePack.swift
@@ -0,0 +1,233 @@
+//
+//  ShapeStylePack.swift
+//  OpenSwiftUICore
+//
+//  Audited for iOS 18.0
+//  Status: Blocked by other ShapeStyle and Animatable
+//  ID: 4DBF651155A4B32ED86C55EAB1B96C61 (SwiftUICore)
+
+package struct _ShapeStyle_Pack: Equatable {
+    package struct Style: Equatable, Sendable {
+        package var fill: _ShapeStyle_Pack.Fill
+        package var opacity: Float
+        package var _blend: GraphicsBlendMode?
+        
+        package var blend: GraphicsBlendMode {
+            _blend ?? .normal
+        }
+
+        package var effects: [_ShapeStyle_Pack.Effect]
+        
+        package init(_ fill: _ShapeStyle_Pack.Fill) {
+            self.fill = fill
+            self.opacity = 1.0
+            self._blend = .normal
+            self.effects = []
+        }
+        
+        package static let clear: _ShapeStyle_Pack.Style = .init(.color(.clear))
+        package static func == (a: _ShapeStyle_Pack.Style, b: _ShapeStyle_Pack.Style) -> Bool {
+            a.fill == b.fill && a.opacity == b.opacity && a._blend == b._blend && a.effects == b.effects
+        }
+    }
+    
+    package enum Fill: Equatable, Sendable {
+        case color(Color.Resolved)
+        case paint(AnyResolvedPaint)
+        case foregroundMaterial(Color.Resolved/*, ContentStyle.MaterialStyle*/)
+        // case backgroundMaterial(Material.ResolvedMaterial)
+        // case vibrantColor(Color.ResolvedVibrant)
+        // case vibrantMatrix(_ColorMatrix)
+        // case multicolor(ResolvedMulticolorStyle)
+        package static func == (a: _ShapeStyle_Pack.Fill, b: _ShapeStyle_Pack.Fill) -> Bool {
+            switch (a, b) {
+                case (.color(let a), .color(let b)): return a == b
+                case (.paint(let a), .paint(let b)): return a == b
+                default: return false
+            }
+        }
+    }
+    
+    package struct Effect: Equatable, Sendable {
+        package enum Kind: Equatable, Sendable {
+            case none
+            // case shadow(ResolvedShadowStyle)
+            // package static func == (a: _ShapeStyle_Pack.Effect.Kind, b: _ShapeStyle_Pack.Effect.Kind) -> Bool
+        }
+
+        package var kind: _ShapeStyle_Pack.Effect.Kind
+        package var opacity: Float
+        package var _blend: GraphicsBlendMode?
+        package var blend: GraphicsBlendMode {
+            _blend ?? .normal
+        }
+        
+        package static func == (a: _ShapeStyle_Pack.Effect, b: _ShapeStyle_Pack.Effect) -> Bool {
+            a.kind == b.kind && a.opacity == b.opacity && a._blend == b._blend
+        }
+    }
+        
+    package struct Key: Comparable {
+        package var name: _ShapeStyle_Name
+        var _level: UInt8
+        
+        package init(_ name: _ShapeStyle_Name, _ level: Int) {
+            self.name = name
+            self._level = UInt8(level)
+        }
+        
+        package var level: Int {
+            get { Int(bitPattern: UInt(_level)) } // FIXME
+            set { _level = UInt8(truncatingIfNeeded: newValue) }
+        }
+        
+        package static func < (lhs: _ShapeStyle_Pack.Key, rhs: _ShapeStyle_Pack.Key) -> Bool {
+            lhs.name < rhs.name || (lhs.name == rhs.name && lhs._level < rhs._level)
+        }
+        
+        package static func == (a: _ShapeStyle_Pack.Key, b: _ShapeStyle_Pack.Key) -> Bool {
+            a.name == b.name && a._level == b._level
+        }
+    }
+    
+    var styles: [(key: Key, style: Style)]
+    
+    package init() {
+        styles = []
+    }
+    
+    package static func style(_ style: _ShapeStyle_Pack.Style, name: _ShapeStyle_Name, level: Int = 0) -> _ShapeStyle_Pack {
+        var pack = _ShapeStyle_Pack()
+        pack.styles = [(key: Key(name, level), style: style)]
+        return pack
+    }
+    
+    package static func fill(_ fill: _ShapeStyle_Pack.Fill, name: _ShapeStyle_Name, level: Int = 0) -> _ShapeStyle_Pack {
+        var pack = _ShapeStyle_Pack()
+        pack.styles = [(key: Key(name, level), style: .init(fill))]
+        return pack
+    }
+    
+    package static func == (lhs: _ShapeStyle_Pack, rhs: _ShapeStyle_Pack) -> Bool {
+        lhs.styles.elementsEqual(rhs.styles) { $0.key == $1.key && $0.style == $1.style }
+    }
+    
+    package static let defaultValue: _ShapeStyle_Pack = .init()
+    
+    package subscript(name: _ShapeStyle_Name, level: Int) -> _ShapeStyle_Pack.Style {
+        get {
+            styles.first { $0.key.name == name && $0.key.level == level }?.style ?? _ShapeStyle_Pack.Style.clear
+        }
+        set {
+            if let index = styles.firstIndex(where: { $0.key.name == name && $0.key.level == level }) {
+                styles[index].style = newValue
+            } else {
+                styles.append((key: Key(name, level), style: newValue))
+            }
+        }
+    }
+    
+    package subscript(name: _ShapeStyle_Name) -> _ShapeStyle_Pack.Slice {
+        Slice(pack: self, name: name)
+    }
+    
+    package struct Slice: RandomAccessCollection {
+        var styles: ArraySlice<(key: Key, style: Style)>
+        var baseLevel: UInt8
+        
+        init(pack: _ShapeStyle_Pack, name: _ShapeStyle_Name) {
+            fatalError("TODO")
+        }
+        
+        package var startIndex: Int {
+            styles.startIndex
+        }
+        
+        package var endIndex: Int {
+            fatalError("TODO")
+        }
+        
+        package subscript(level: Int) -> _ShapeStyle_Pack.Style {
+            fatalError("TODO")
+        }
+    }
+    
+    package mutating func modify(name: _ShapeStyle_Name, levels: Range<Int>, _ modifier: (inout _ShapeStyle_Pack.Style) -> Void) {
+        fatalError("TODO")
+    }
+    
+    package mutating func adjustLevelIndices(of name: _ShapeStyle_Name, by offset: Int) {
+        fatalError("TODO")
+    }
+    
+    package mutating func createOpacities(count: Int, name: _ShapeStyle_Name, environment: EnvironmentValues) {
+        fatalError("TODO")
+    }
+    
+    package func isClear(name: _ShapeStyle_Name) -> Bool {
+        fatalError("TODO")
+    }
+    
+    package subscript(colorName: String) -> Color.Resolved? {
+        fatalError("TODO")
+    }
+}
+
+extension _ShapeStyle_Pack.Slice {
+    package var allColors: Bool {
+        fatalError("TODO")
+    }
+}
+
+extension _ShapeStyle_Pack.Style {
+    package var isClear: Bool {
+        if opacity == 0 {
+            return true
+        } else {
+            switch fill {
+                // TODO
+                default: return false
+            }
+        }
+    }
+    
+    package var ignoresBackdrop: Bool {
+        fatalError("TODO")
+    }
+    
+    package mutating func applyOpacity(_ opacity: Float) {
+        fatalError("TODO")
+    }
+    
+    package func applyingOpacity(_ opacity: Float) -> _ShapeStyle_Pack.Style {
+        fatalError("TODO")
+    }
+    
+    package mutating func applyBlend(_ blend: GraphicsBlendMode) {
+        fatalError("TODO")
+    }
+    
+    package var color: Color.Resolved? {
+        fatalError("TODO")
+    }
+}
+
+// TODO: _ShapeStyle_Pack + Animatable
+
+// MARK: - _ShapeStyle_Shape + _ShapeStyle_Pack
+
+extension _ShapeStyle_Shape {
+    package var stylePack: _ShapeStyle_Pack {
+        get {
+            switch result {
+                case let .pack(pack): pack
+                default: .defaultValue
+            }
+        }
+        _modify {
+            var pack = stylePack
+            yield &pack
+            result = .pack(pack)
+        }
+    }
+}
diff --git a/Sources/OpenSwiftUICore/Shape/ShapeStyle/ShapeStyleRenderedShape.swift b/Sources/OpenSwiftUICore/Shape/ShapeStyle/ShapeStyleRenderedShape.swift
new file mode 100644
index 00000000..9eda78c8
--- /dev/null
+++ b/Sources/OpenSwiftUICore/Shape/ShapeStyle/ShapeStyleRenderedShape.swift
@@ -0,0 +1,20 @@
+//
+//  ShapeStyle_RenderedShape.swift
+//  OpenSwiftUICore
+//
+//  Audited for iOS 18.0
+//  Status: WIP
+//  ID: 3890C65F12EA82A4BC5FBD33046B67FA (?)
+
+extension ShapeStyle {
+    package typealias RenderedShape = _ShapeStyle_RenderedShape
+}
+package struct _ShapeStyle_RenderedShape {
+    package enum Shape {
+        case empty
+        case path(Path, FillStyle)
+        // case text(StyledTextContentView)
+        // case image(GraphicsImage)
+        case alphaMask(DisplayList.Item)
+    }
+}
diff --git a/Sources/OpenSwiftUICore/Shape/ShapeStyle/ShapeStyleResolver.swift b/Sources/OpenSwiftUICore/Shape/ShapeStyle/ShapeStyleResolver.swift
new file mode 100644
index 00000000..5022d56d
--- /dev/null
+++ b/Sources/OpenSwiftUICore/Shape/ShapeStyle/ShapeStyleResolver.swift
@@ -0,0 +1,40 @@
+//
+//  ShapeStyleResolver.swift
+//  OpenSwiftUICore
+//
+//  Audited for iOS 18.0
+//  Status: WIP
+
+package import OpenGraphShims
+
+package struct ShapeStyleResolver<Style>: StatefulRule, AsyncAttribute, ObservedAttribute where Style: ShapeStyle {
+    @OptionalAttribute var style: Style?
+    @OptionalAttribute var mode: _ShapeStyle_ResolverMode?
+    @Attribute var environment: EnvironmentValues
+    var role: ShapeRole
+    var animationsDisabled: Bool
+    // var helper: AnimatableAttributeHelper<_ShapeStyle_Pack>
+    let tracker: PropertyList.Tracker
+    
+    package typealias Value = _ShapeStyle_Pack
+    
+    package init(
+        style: OptionalAttribute<Style> = .init(),
+        mode: OptionalAttribute<_ShapeStyle_ResolverMode> = .init(),
+        environment: Attribute<EnvironmentValues>,
+        role: ShapeRole,
+        animationsDisabled: Bool
+    // helper: AnimatableAttributeHelper<_ShapeStyle_Pack>
+    ) {
+        fatalError("TODO")
+    }
+    
+    package mutating func updateValue() {
+        fatalError()
+    }
+    
+    package func destroy() {
+        // Blocked by _ShapeStyle_Pack
+        fatalError("TODO")
+    }
+}
diff --git a/Sources/OpenSwiftUICore/Shape/ShapeStyle/ShapeStyleResolverMode.swift b/Sources/OpenSwiftUICore/Shape/ShapeStyle/ShapeStyleResolverMode.swift
new file mode 100644
index 00000000..634492d8
--- /dev/null
+++ b/Sources/OpenSwiftUICore/Shape/ShapeStyle/ShapeStyleResolverMode.swift
@@ -0,0 +1,37 @@
+//
+//  ShapeStyle_ResolverMode.swift
+//  OpenSwiftUICore
+//
+//  Audited for iOS 18.0
+//  Status: Blocked by Image.Location
+
+package import Foundation
+
+package struct _ShapeStyle_ResolverMode: Equatable {
+    package var bundle: Bundle?
+    package var foregroundLevels: UInt16
+    package struct Options: OptionSet {
+        package let rawValue: UInt8
+        package init(rawValue: UInt8) { self.rawValue = rawValue }
+        
+        package static let foregroundPalette: Options = .init(rawValue: 1 << 0)
+        package static let background: Options = .init(rawValue: 1 << 1)
+        package static let multicolor: Options = .init(rawValue: 1 << 2)
+    }
+  
+    package var options: Options
+
+    package init(foregroundLevels: UInt16 = 0, options: Options = .init()) {
+        self.bundle = nil
+        self.foregroundLevels = foregroundLevels
+        self.options = options
+    }
+    
+    // package init(rbSymbolStyleMask mask: UInt32, location: Image.Location)
+
+    package mutating func formUnion(_ rhs: _ShapeStyle_ResolverMode) {
+        bundle = bundle ?? rhs.bundle
+        foregroundLevels = max(foregroundLevels, rhs.foregroundLevels)
+        options.formUnion(rhs.options)
+    }
+}
diff --git a/Sources/OpenSwiftUICore/Shape/ShapeStyle/ShapeStyleShape.swift b/Sources/OpenSwiftUICore/Shape/ShapeStyle/ShapeStyleShape.swift
new file mode 100644
index 00000000..56b79085
--- /dev/null
+++ b/Sources/OpenSwiftUICore/Shape/ShapeStyle/ShapeStyleShape.swift
@@ -0,0 +1,121 @@
+//
+//  ShapeStyle_Shape.swift
+//  OpenSwiftUICore
+//
+//  Audited for iOS 18.0
+//  Status: Blocked by Color / ColorProvider / Color.Resolved
+
+package import Foundation
+
+// MARK: - _ShapeStyle_Shape
+
+public struct _ShapeStyle_Shape {
+    package enum Operation {
+        case prepareText(level: Int)
+        case resolveStyle(name: _ShapeStyle_Name, levels: Range<Int>)
+        case multiLevel
+        case fallbackColor(level: Int)
+        case copyStyle(name: _ShapeStyle_Name)
+        case primaryStyle
+        case modifyBackground(level: Int)
+    }
+    
+    package enum Result {
+        case none
+        case preparedText(PreparedTextResult)
+        case pack(_ShapeStyle_Pack)
+        case style(AnyShapeStyle)
+        case color(Color)
+        case bool(Bool)
+    }
+    
+    package enum PreparedTextResult {
+        case foregroundKeyColor
+        case foregroundColor(Color)
+    }
+    
+    package var operation: Operation
+    package var result: Result
+    package var environment: EnvironmentValues
+    package var foregroundStyle: AnyShapeStyle?
+    package var bounds: CGRect?
+    package var role: ShapeRole
+
+    package init(
+        operation: Operation,
+        result: Result = .none,
+        environment: EnvironmentValues = .init(),
+        foregroundStyle: AnyShapeStyle? = nil,
+        bounds: CGRect? = nil,
+        role: ShapeRole = .fill
+    ) {
+        self.operation = operation
+        self.result = result
+        self.environment = environment
+        self.foregroundStyle = foregroundStyle
+        self.bounds = bounds
+        self.role = role
+    }
+
+    package struct RecursiveStyles: OptionSet {
+        package let rawValue: UInt8
+        package init(rawValue: UInt8) {
+            self.rawValue = rawValue
+        }
+        
+        package static let content: RecursiveStyles = .init(rawValue: 1 << 0)
+        package static let foreground: RecursiveStyles = .init(rawValue: 1 << 1)
+        package static let background: RecursiveStyles = .init(rawValue: 1 << 2)
+    }
+    
+    package var activeRecursiveStyles: RecursiveStyles = []
+    
+    package func opacity(at level: Int) -> Float {
+        // Blocked by Color
+        fatalError("TODO")
+    }
+    
+    package func opacity(for color: Color, at level: Int) -> Float {
+        // Blocked by Color
+        fatalError("TODO")
+    }
+    package func applyingOpacity(at level: Int, to color: Color) -> Color {
+        // Blocked by Color
+        fatalError("TODO")
+    }
+    
+    package func applyingOpacity(at level: Int, to color: Color.Resolved) -> Color.Resolved {
+        // Blocked by Color
+        fatalError("TODO")
+    }
+    
+    package var currentForegroundStyle: AnyShapeStyle? {
+        environment.currentForegroundStyle
+    }
+    
+    package var effectiveForegroundStyle: AnyShapeStyle {
+        environment._effectiveForegroundStyle
+    }
+}
+
+@available(*, unavailable)
+extension _ShapeStyle_Shape: Sendable {}
+
+// MARK: - _ShapeStyle_ShapeType
+
+public struct _ShapeStyle_ShapeType {
+    package enum Operation {
+        case modifiesBackground
+    }
+    
+    package enum Result {
+        case none
+        case bool(Bool)
+    }
+    
+    package var operation: Operation
+    package var result: Result
+}
+
+@available(*, unavailable)
+extension _ShapeStyle_ShapeType: Sendable {}
diff --git a/Sources/OpenSwiftUICore/Shape/ShapeStyle/ShapeStyledLeadView.swift b/Sources/OpenSwiftUICore/Shape/ShapeStyle/ShapeStyledLeadView.swift
index 552167cd..c33b2b87 100644
--- a/Sources/OpenSwiftUICore/Shape/ShapeStyle/ShapeStyledLeadView.swift
+++ b/Sources/OpenSwiftUICore/Shape/ShapeStyle/ShapeStyledLeadView.swift
@@ -1,14 +1,20 @@
 //
 //  ShapeStyledLeadView.swift
-//  OpenSwiftUI
+//  OpenSwiftUICore
 //
-//  Audited for iOS 15.5
+//  Audited for iOS 18.0
 //  Status: WIP
 
-import Foundation
+package import Foundation
+package import OpenGraphShims
 
-protocol ShapeStyledLeafView: ContentResponder {
+package protocol ShapeStyledLeafView: ContentResponder {
     static var animatesSize: Bool { get }
-    func shape(size: CGSize) /*-> (ShapeStyle_RenderShape.Shape, CGRect)*/
-    func isClear(style: _ShapeStyle_Shape.ResolvedStyle)
+    associatedtype ShapeUpdateData = Void
+    mutating func mustUpdate(data: ShapeUpdateData, position: Attribute<ViewOrigin>) -> Bool
+    typealias FramedShape =  (shape: _ShapeStyle_RenderedShape.Shape, frame: CGRect)
+    func shape(in size: CGSize) -> FramedShape
+    static var hasBackground: Bool { get }
+    func backgroundShape(in size: CGSize) -> FramedShape
+    func isClear(styles: _ShapeStyle_Pack) -> Bool
 }