diff --git a/Package.resolved b/Package.resolved
index 7905b930..f288005d 100644
--- a/Package.resolved
+++ b/Package.resolved
@@ -6,7 +6,7 @@
       "location" : "https://github.com/OpenSwiftUIProject/OpenGraph",
       "state" : {
         "branch" : "main",
-        "revision" : "2435a0a02b3ab3b97799a8f387284686fe9e6a7a"
+        "revision" : "ed01e7196afe56bf953f2f14b0b463208dda9c8d"
       }
     },
     {
diff --git a/Sources/OpenSwiftUI/Core/Attribute/AsyncAttribute.swift b/Sources/OpenSwiftUI/Core/Attribute/AsyncAttribute.swift
new file mode 100644
index 00000000..a92582b5
--- /dev/null
+++ b/Sources/OpenSwiftUI/Core/Attribute/AsyncAttribute.swift
@@ -0,0 +1,16 @@
+//
+//  AsyncAttribute.swift
+//  OpenSwiftUI
+//
+//  Audited for RELEASE_2021
+//  Status: WIP
+
+internal import OpenGraphShims
+
+protocol AsyncAttribute: _AttributeBody {}
+
+extension Attribute {
+    func syncMainIfReferences<V>(do body: (Value) -> V) -> V {
+        fatalError("TODO")
+    }
+}
diff --git a/Sources/OpenSwiftUI/Core/Data/Boxes/Indirect.swift b/Sources/OpenSwiftUI/Core/Data/Boxes/Indirect.swift
index 70824a01..79fd0678 100644
--- a/Sources/OpenSwiftUI/Core/Data/Boxes/Indirect.swift
+++ b/Sources/OpenSwiftUI/Core/Data/Boxes/Indirect.swift
@@ -8,7 +8,7 @@
 struct Indirect<A> {
     var box : MutableBox<A>
 
-    var value: A { box.value }
+    var value: A { box.wrappedValue }
 }
 
 extension Indirect: Equatable where A: Equatable {
diff --git a/Sources/OpenSwiftUI/Core/Data/Boxes/MutableBox.swift b/Sources/OpenSwiftUI/Core/Data/Boxes/MutableBox.swift
index 11cde23a..07fbca72 100644
--- a/Sources/OpenSwiftUI/Core/Data/Boxes/MutableBox.swift
+++ b/Sources/OpenSwiftUI/Core/Data/Boxes/MutableBox.swift
@@ -7,7 +7,7 @@
 
 @propertyWrapper
 final class MutableBox<A> {
-    var value: A
+    private var value: A
 
     var wrappedValue: A {
         get { value }
diff --git a/Sources/OpenSwiftUI/Data/Environment/CachedEnvironment.swift b/Sources/OpenSwiftUI/Data/Environment/CachedEnvironment.swift
new file mode 100644
index 00000000..be8bb48c
--- /dev/null
+++ b/Sources/OpenSwiftUI/Data/Environment/CachedEnvironment.swift
@@ -0,0 +1,132 @@
+//
+//  CachedEnvironment.swift
+//  OpenSwiftUI
+//
+//  Audited for RELEASE_2021
+//  Status: WIP
+//  ID: C424ABD9FC88B2DFD0B7B2319F2E7987
+
+import Foundation
+internal import OpenGraphShims
+
+struct CachedEnvironment {
+    var environment: Attribute<EnvironmentValues>
+    private var items: [Item]
+    #if canImport(Darwin)
+    private var constants: [HashableConstant: OGAttribute]
+    #endif
+    private var animatedFrame: AnimatedFrame?
+    // private var resolvedFgStyles: [ResolvedFgStyle : Swift<_ShapeStyle_Resolved.ResolvedFg>]
+    
+    init(_ environment: Attribute<EnvironmentValues>) {
+        self.environment = environment
+        items = []
+        #if canImport(Darwin)
+        constants = [:]
+        #endif
+        animatedFrame = nil
+        // resolvedFgStyles = [:]
+    }
+    
+    func intern<Value>(_ value: Value, id: Int) -> Attribute<Value> {
+        fatalError("TODO")
+    }
+    
+    func animatePosition(for inputs: _ViewInputs) -> Attribute<ViewOrigin> {
+        fatalError("TODO")
+    }
+    
+    func animateSize(for inputs: _ViewInputs) -> Attribute<ViewSize> {
+        fatalError("TODO")
+    }
+    
+    // func resolvedForegroundStyle() {}
+}
+
+extension CachedEnvironment {
+    private struct Item {
+        var key: PartialKeyPath<EnvironmentValues>
+        #if canImport(Darwin)
+        var value: OGAttribute
+        #endif
+    }
+}
+
+private protocol _Constant {
+    func hash(into hasher: inout Hasher)
+    func isEqual(to other: _Constant) -> Bool
+}
+
+private struct Constant<Value>: _Constant {
+    let value: Value
+    let id: Int
+    
+    init(_ value: Value, id: Int) {
+        self.value = value
+        self.id = id
+    }
+    
+    func hash(into hasher: inout Hasher) {
+        hasher.combine(ObjectIdentifier(Value.self))
+        hasher.combine(id)
+    }
+    
+    func isEqual(to other: _Constant) -> Bool {
+        let otherConstant = other as? Constant<Value>
+        return otherConstant.map { id == $0.id } ?? false
+    }
+}
+
+private struct HashableConstant: Hashable {
+    let value: _Constant
+    
+    init<Value>(_ value: Value, id: Int) {
+        self.value = Constant(value, id: id)
+    }
+    
+    func hash(into hasher: inout Hasher) {
+        value.hash(into: &hasher)
+    }
+    
+    static func == (lhs: HashableConstant, rhs: HashableConstant) -> Bool {
+        lhs.value.isEqual(to: rhs.value)
+    }
+}
+
+private struct AnimatedFrame {
+    let position: Attribute<ViewOrigin>
+    let size: Attribute<ViewSize>
+    let pixelLength: Attribute<CGFloat>
+    let time: Attribute<Time>
+    let transaction: Attribute<Transaction>
+    let viewPhase: Attribute<_GraphInputs.Phase>
+    let animatedFrame: Attribute<ViewFrame>
+    private var _animatedPosition: Attribute<ViewOrigin>?
+    private var _animatedSize: Attribute<ViewSize>?
+    
+    mutating func animatePosition() -> Attribute<ViewOrigin> {
+        guard let _animatedPosition else {
+            // FIXME
+            let animatePosition = animatedFrame.unsafeOffset(
+                at: 0,
+                as:ViewOrigin.self
+            )
+            _animatedPosition = animatePosition
+            return animatePosition
+        }
+        return _animatedPosition
+    }
+    
+    mutating func animateSize() -> Attribute<ViewSize> {
+        guard let _animatedSize else {
+            // FIXME
+            let animatedSize = animatedFrame.unsafeOffset(
+                at: MemoryLayout<ViewOrigin>.size,
+                as: ViewSize.self
+            )
+            _animatedSize = animatedSize
+            return animatedSize
+        }
+        return _animatedSize
+    }
+}
diff --git a/Sources/OpenSwiftUI/Data/Environment/Internal/DerivedEnvironmentKey.swift b/Sources/OpenSwiftUI/Data/Environment/DerivedEnvironmentKey.swift
similarity index 100%
rename from Sources/OpenSwiftUI/Data/Environment/Internal/DerivedEnvironmentKey.swift
rename to Sources/OpenSwiftUI/Data/Environment/DerivedEnvironmentKey.swift
diff --git a/Sources/OpenSwiftUI/Data/Environment/Environment.swift b/Sources/OpenSwiftUI/Data/Environment/Environment.swift
new file mode 100644
index 00000000..2fe799a8
--- /dev/null
+++ b/Sources/OpenSwiftUI/Data/Environment/Environment.swift
@@ -0,0 +1,259 @@
+//
+//  Environment.swift
+//  OpenSwiftUI
+//
+//  Audited for RELEASE_2021
+//  Status: Complete
+//  ID: 7B48F30970137591804EEB8D0D309152
+
+internal import OpenGraphShims
+
+/// A property wrapper that reads a value from a view's environment.
+///
+/// Use the `Environment` property wrapper to read a value
+/// stored in a view's environment. Indicate the value to read using an
+/// ``EnvironmentValues`` key path in the property declaration. For example, you
+/// can create a property that reads the color scheme of the current
+/// view using the key path of the ``EnvironmentValues/colorScheme``
+/// property:
+///
+///     @Environment(\.colorScheme) var colorScheme: ColorScheme
+///
+/// You can condition a view's content on the associated value, which
+/// you read from the declared property's ``wrappedValue``. As with any property
+/// wrapper, you access the wrapped value by directly referring to the property:
+///
+///     if colorScheme == .dark { // Checks the wrapped value.
+///         DarkContent()
+///     } else {
+///         LightContent()
+///     }
+///
+/// If the value changes, OpenSwiftUI updates any parts of your view that depend on
+/// the value. For example, that might happen in the above example if the user
+/// changes the Appearance settings.
+///
+/// You can use this property wrapper to read --- but not set --- an environment
+/// value. OpenSwiftUI updates some environment values automatically based on system
+/// settings and provides reasonable defaults for others. You can override some
+/// of these, as well as set custom environment values that you define,
+/// using the ``View/environment(_:_:)`` view modifier.
+///
+/// For the complete list of environment values provided by OpenSwiftUI, see the
+/// properties of the ``EnvironmentValues`` structure. For information about
+/// creating custom environment values, see the ``EnvironmentKey`` protocol.
+///
+/// ### Get an observable object
+///
+/// You can also use `Environment` to get an observable object from a view's
+/// environment. The observable object must conform to the
+/// <doc://com.apple.documentation/documentation/Observation/Observable>
+/// protocol, and your app must set the object in the environment using the
+/// the object itself or a key path.
+///
+/// To set the object in the environment using the object itself, use the
+/// ``View/environment(_:)-4516h`` modifier:
+///
+///     @Observable
+///     class Library {
+///         var books: [Book] = [Book(), Book(), Book()]
+///
+///         var availableBooksCount: Int {
+///             books.filter(\.isAvailable).count
+///         }
+///     }
+///
+///     @main
+///     struct BookReaderApp: App {
+///         @State private var library = Library()
+///
+///         var body: some Scene {
+///             WindowGroup {
+///                 LibraryView()
+///                     .environment(library)
+///             }
+///         }
+///     }
+///
+/// To get the observable object using its type, create a property and provide
+/// the `Environment` property wrapper the object's type:
+///
+///     struct LibraryView: View {
+///         @Environment(Library.self) private var library
+///
+///         var body: some View {
+///             // ...
+///         }
+///     }
+///
+/// By default, reading an object from the environment returns a non-optional
+/// object when using the object type as the key. This default behavior assumes
+/// that a view in the current hierarchy previously stored a non-optional
+/// instance of the type using the ``View/environment(_:)-4516h`` modifier. If
+/// a view attempts to retrieve an object using its type and that object isn't
+/// in the environment, OpenSwiftUI throws an exception.
+///
+/// In cases where there is no guarantee that an object is in the environment,
+/// retrieve an optional version of the object as shown in the following code.
+/// If the object isn't available the environment, OpenSwiftUI returns `nil`
+/// instead of throwing an exception.
+///
+///     @Environment(Library.self) private var library: Library?
+///
+/// ### Get an observable object using a key path
+///
+/// To set the object with a key path, use the ``View/environment(_:_:)``
+/// modifier:
+///
+///     @Observable
+///     class Library {
+///         var books: [Book] = [Book(), Book(), Book()]
+///
+///         var availableBooksCount: Int {
+///             books.filter(\.isAvailable).count
+///         }
+///     }
+///
+///     @main
+///     struct BookReaderApp: App {
+///         @State private var library = Library()
+///
+///         var body: some Scene {
+///             WindowGroup {
+///                 LibraryView()
+///                     .environment(\.library, library)
+///             }
+///         }
+///     }
+///
+/// To get the object, create a property and specify the key path:
+///
+///     struct LibraryView: View {
+///         @Environment(\.library) private var library
+///
+///         var body: some View {
+///             // ...
+///         }
+///     }
+///
+@frozen
+@propertyWrapper
+public struct Environment<Value>: DynamicProperty {
+    @usableFromInline
+    @frozen
+    enum Content {
+        case keyPath(KeyPath<EnvironmentValues, Value>)
+        case value(Value)
+    }
+
+    @usableFromInline
+    var content: Content
+
+    /// Creates an environment property to read the specified key path.
+    ///
+    /// Don’t call this initializer directly. Instead, declare a property
+    /// with the ``Environment`` property wrapper, and provide the key path of
+    /// the environment value that the property should reflect:
+    ///
+    ///     struct MyView: View {
+    ///         @Environment(\.colorScheme) var colorScheme: ColorScheme
+    ///
+    ///         // ...
+    ///     }
+    ///
+    /// OpenSwiftUI automatically updates any parts of `MyView` that depend on
+    /// the property when the associated environment value changes.
+    /// You can't modify the environment value using a property like this.
+    /// Instead, use the ``View/environment(_:_:)`` view modifier on a view to
+    /// set a value for a view hierarchy.
+    ///
+    /// - Parameter keyPath: A key path to a specific resulting value.
+    @inlinable
+    public init(_ keyPath: KeyPath<EnvironmentValues, Value>) {
+        content = .keyPath(keyPath)
+    }
+
+    /// The current value of the environment property.
+    ///
+    /// The wrapped value property provides primary access to the value's data.
+    /// However, you don't access `wrappedValue` directly. Instead, you read the
+    /// property variable created with the ``Environment`` property wrapper:
+    ///
+    ///     @Environment(\.colorScheme) var colorScheme: ColorScheme
+    ///
+    ///     var body: some View {
+    ///         if colorScheme == .dark {
+    ///             DarkContent()
+    ///         } else {
+    ///             LightContent()
+    ///         }
+    ///     }
+    ///
+    @inlinable
+    public var wrappedValue: Value {
+        switch content {
+        case let .value(value):
+            return value
+        case let .keyPath(keyPath):
+            return EnvironmentValues()[keyPath: keyPath]
+        }
+    }
+
+    @usableFromInline
+    func error() -> Never {
+        fatalError("Reading Environment<\(Value.self)> outside View.body")
+    }
+
+    public static func _makeProperty<V>(
+        in buffer: inout _DynamicPropertyBuffer,
+        container _: _GraphValue<V>,
+        fieldOffset: Int,
+        inputs: inout _GraphInputs
+    ) {
+        buffer.append(
+            EnvironmentBox<Value>(
+                environment: inputs.cachedEnvironment.wrappedValue.environment
+            ),
+            fieldOffset: fieldOffset
+        )
+    }
+}
+
+private struct EnvironmentBox<Value>: DynamicPropertyBox {
+    @Attribute<EnvironmentValues>
+    var environment: EnvironmentValues
+    var keyPath: KeyPath<EnvironmentValues, Value>?
+    var value: Value?
+    
+    init(environment: Attribute<EnvironmentValues>) {
+        _environment = environment
+        keyPath = nil
+        value = nil
+    }
+        
+    func destroy() {}
+    func reset() {}
+    mutating func update(property: inout Environment<Value>, phase _: _GraphInputs.Phase) -> Bool {
+        guard case let .keyPath(propertyKeyPath) = property.content else {
+            return false
+        }
+        let (environment, environmentChanged) = _environment.changedValue(options: [])
+        let keyPathChanged = (propertyKeyPath != keyPath)
+        if keyPathChanged { keyPath = propertyKeyPath }
+        let valueChanged: Bool
+        if keyPathChanged || environmentChanged {
+            let newValue = environment[keyPath: propertyKeyPath]
+            if let value, compareValues(value, newValue) {
+                valueChanged = false
+            } else {
+                value = newValue
+                valueChanged = true
+            }
+        } else {
+            valueChanged = false
+        }
+        let value: Value = self.value!
+        property.content = .value(value)
+        return valueChanged
+    }
+}
diff --git a/Sources/OpenSwiftUI/Data/Environment/EnvironmentKeyTransformModifier.swift b/Sources/OpenSwiftUI/Data/Environment/EnvironmentKeyTransformModifier.swift
new file mode 100644
index 00000000..a2e5cb59
--- /dev/null
+++ b/Sources/OpenSwiftUI/Data/Environment/EnvironmentKeyTransformModifier.swift
@@ -0,0 +1,93 @@
+//
+//  EnvironmentKeyTransformModifier.swift
+//  OpenSwiftUI
+//
+//  Audited for RELEASE_2021
+//  Status: Blocked by syncMainIfReferences
+//  ID: 1DBD4F024EFF0E73A70DB6DD05D5B548
+
+internal import OpenGraphShims
+
+@frozen
+public struct _EnvironmentKeyTransformModifier<Value>: PrimitiveViewModifier, _GraphInputsModifier {
+    public var keyPath: WritableKeyPath<EnvironmentValues, Value>
+    public var transform: (inout Value) -> Void
+    
+    @inlinable
+    public init(keyPath: WritableKeyPath<EnvironmentValues, Value>, transform: @escaping (inout Value) -> Void) {
+        self.keyPath = keyPath
+        self.transform = transform
+    }
+
+    public static func _makeInputs(modifier: _GraphValue<Self>, inputs: inout _GraphInputs) {
+        let childEnvironment = ChildEnvironment(
+            modifier: modifier.value,
+            environment: inputs.cachedEnvironment.wrappedValue.environment,
+            oldKeyPath: nil
+        )
+        let attribute = Attribute(childEnvironment)
+        let cachedEnvironment = CachedEnvironment(attribute)  
+        inputs.cachedEnvironment = MutableBox(cachedEnvironment)
+        inputs.changedDebugProperties.insert(.environment)
+    }
+}
+
+extension View {
+    /// Transforms the environment value of the specified key path with the
+    /// given function.
+    @inlinable
+    public func transformEnvironment<V>(
+        _ keyPath: WritableKeyPath<EnvironmentValues, V>,
+        transform: @escaping (inout V) -> Void
+    ) -> some View {
+        modifier(_EnvironmentKeyTransformModifier(
+            keyPath: keyPath,
+            transform: transform
+        ))
+    }
+}
+
+private struct ChildEnvironment<Value>: StatefulRule, AsyncAttribute {
+    @Attribute
+    private var modifier: _EnvironmentKeyTransformModifier<Value>
+    private var _environment: Attribute<EnvironmentValues>
+    private var oldValue: Value?
+    private var oldKeyPath: WritableKeyPath<EnvironmentValues, Value>?
+    
+    init(modifier: Attribute<_EnvironmentKeyTransformModifier<Value>>,
+         environment: Attribute<EnvironmentValues>,
+         oldValue: Value? = nil,
+         oldKeyPath: WritableKeyPath<EnvironmentValues, Value>?
+    ) {
+        _modifier = modifier
+        _environment = environment
+        self.oldValue = oldValue
+        self.oldKeyPath = oldKeyPath
+    }
+    
+    var description: String {
+        "EnvironmentTransform: EnvironmentValues"
+    }
+    
+    typealias Value = EnvironmentValues
+    
+    mutating func updateValue() {
+        var (environment, environmentChanged) = _environment.changedValue()
+        let keyPath = modifier.keyPath
+        var newValue = environment[keyPath: keyPath]
+        _modifier.syncMainIfReferences { modifier in
+            modifier.transform(&newValue)
+        }
+        guard !environmentChanged,
+              let valueChanged = oldValue.map({ compareValues($0, newValue, mode: ._2) }), !valueChanged,
+              let keyPathChanged = oldKeyPath.map({ $0 == keyPath }), !keyPathChanged,
+              hasValue
+        else {
+            environment[keyPath: keyPath] = newValue
+            value = environment
+            oldValue = newValue
+            oldKeyPath = keyPath
+            return
+        }
+    }
+}
diff --git a/Sources/OpenSwiftUI/Data/Environment/Internal/TODO/CachedEnvironment.swift b/Sources/OpenSwiftUI/Data/Environment/Internal/TODO/CachedEnvironment.swift
deleted file mode 100644
index 1f46094d..00000000
--- a/Sources/OpenSwiftUI/Data/Environment/Internal/TODO/CachedEnvironment.swift
+++ /dev/null
@@ -1,7 +0,0 @@
-internal import OpenGraphShims
-
-struct CachedEnvironment {
-    init(_ environment: Attribute<EnvironmentValues>) {
-        // TODO
-    }
-}
diff --git a/Sources/OpenSwiftUI/Data/Environment/Internal/TODO/_EnvironmentKeyTransformModifier.swift b/Sources/OpenSwiftUI/Data/Environment/Internal/TODO/_EnvironmentKeyTransformModifier.swift
deleted file mode 100644
index 3f2d877f..00000000
--- a/Sources/OpenSwiftUI/Data/Environment/Internal/TODO/_EnvironmentKeyTransformModifier.swift
+++ /dev/null
@@ -1,40 +0,0 @@
-//
-//  _EnvironmentKeyTransformModifier.swift
-//  OpenSwiftUI
-//
-//  Audited for RELEASE_2021
-//  Status: WIP
-//  ID: 1DBD4F024EFF0E73A70DB6DD05D5B548
-
-@frozen
-public struct _EnvironmentKeyTransformModifier<Value>: PrimitiveViewModifier, _GraphInputsModifier {
-    public var keyPath: WritableKeyPath<EnvironmentValues, Value>
-    public var transform: (inout Value) -> Void
-    
-    @inlinable
-    public init(keyPath: WritableKeyPath<EnvironmentValues, Value>, transform: @escaping (inout Value) -> Void) {
-        self.keyPath = keyPath
-        self.transform = transform
-    }
-
-    public static func _makeInputs(modifier: _GraphValue<_EnvironmentKeyTransformModifier<Value>>, inputs: inout _GraphInputs) {
-
-    }
-}
-
-extension View {
-    @inlinable
-    public func transformEnvironment<V>(
-        _ keyPath: WritableKeyPath<EnvironmentValues, V>,
-        transform: @escaping (inout V) -> Void
-    ) -> some View {
-        modifier(_EnvironmentKeyTransformModifier(
-            keyPath: keyPath,
-            transform: transform
-        ))
-    }
-}
-
-private struct ChildEnvironment {
-    
-}
diff --git a/Sources/OpenSwiftUI/Data/Environment/TODO/Environment.swift b/Sources/OpenSwiftUI/Data/Environment/TODO/Environment.swift
deleted file mode 100644
index 54ab9b3f..00000000
--- a/Sources/OpenSwiftUI/Data/Environment/TODO/Environment.swift
+++ /dev/null
@@ -1,51 +0,0 @@
-//
-//  Environment.swift
-//  OpenSwiftUI
-//
-//  Audited for RELEASE_2021
-//  Status: Empty
-
-@frozen
-@propertyWrapper
-public struct Environment<Value>: DynamicProperty {
-    @usableFromInline
-    @frozen
-    enum Content {
-        // Layout:
-        // - [+0x0] = keypath
-        // - [+0x8]b = 0
-        case keyPath(KeyPath<EnvironmentValues, Value>)
-
-        // Layout:
-        // - [+0x0] = value
-        // - [+0x8]b = 1
-        case value(Value)
-    }
-
-    @usableFromInline
-    var content: Content
-
-    @inlinable public init(_ keyPath: KeyPath<EnvironmentValues, Value>) {
-        content = .keyPath(keyPath)
-    }
-
-    @inlinable public var wrappedValue: Value {
-        switch content {
-        case let .value(value):
-            return value
-        case let .keyPath(keyPath):
-            return EnvironmentValues()[keyPath: keyPath]
-        }
-    }
-
-    // WIP
-    @usableFromInline
-    func error() -> Never {
-        fatalError()
-    }
-
-    // WIP
-    public static func _makeProperty<V>(in buffer: inout _DynamicPropertyBuffer, container: _GraphValue<V>, fieldOffset: Int, inputs: inout _GraphInputs) {
-
-    }
-}
diff --git a/Sources/OpenSwiftUI/Data/Model/DynamicProperty/DynamicPropertyCache.swift b/Sources/OpenSwiftUI/Data/Model/DynamicProperty/DynamicPropertyCache.swift
index 5ffd4567..97a07676 100644
--- a/Sources/OpenSwiftUI/Data/Model/DynamicProperty/DynamicPropertyCache.swift
+++ b/Sources/OpenSwiftUI/Data/Model/DynamicProperty/DynamicPropertyCache.swift
@@ -14,7 +14,7 @@ struct DynamicPropertyCache {
     private static var cache = MutableBox([ObjectIdentifier: Fields]())
     
     static func fields(of type: Any.Type) -> Fields {
-        if let fields = cache.value[ObjectIdentifier(type)] {
+        if let fields = cache.wrappedValue[ObjectIdentifier(type)] {
             return fields
         }
         let fields: Fields
@@ -57,7 +57,7 @@ struct DynamicPropertyCache {
         if fields.behaviors.contains(.init(rawValue: 3)) {
             Log.runtimeIssues("%s is marked async, but contains properties that require the main thread.", [_typeName(type)])
         }
-        cache.value[ObjectIdentifier(type)] = fields
+        cache.wrappedValue[ObjectIdentifier(type)] = fields
         return fields
     }
 }
diff --git a/Sources/OpenSwiftUI/Layout/LayoutFundamentals/internal/ViewFrame.swift b/Sources/OpenSwiftUI/Layout/LayoutFundamentals/internal/ViewFrame.swift
new file mode 100644
index 00000000..edb0ed26
--- /dev/null
+++ b/Sources/OpenSwiftUI/Layout/LayoutFundamentals/internal/ViewFrame.swift
@@ -0,0 +1,11 @@
+//
+//  ViewFrame.swift
+//  OpenSwiftUI
+//
+//  Audited for RELEASE_2021
+//  Status: Complete
+
+struct ViewFrame {
+    var origin: ViewOrigin
+    var size: ViewSize
+}
diff --git a/Sources/OpenSwiftUI/View/Control/Slider/internal/AnySliderStyle.swift b/Sources/OpenSwiftUI/View/Control/Slider/AnySliderStyle.swift
similarity index 94%
rename from Sources/OpenSwiftUI/View/Control/Slider/internal/AnySliderStyle.swift
rename to Sources/OpenSwiftUI/View/Control/Slider/AnySliderStyle.swift
index 2757d7d8..18035f75 100644
--- a/Sources/OpenSwiftUI/View/Control/Slider/internal/AnySliderStyle.swift
+++ b/Sources/OpenSwiftUI/View/Control/Slider/AnySliderStyle.swift
@@ -17,7 +17,7 @@ private class AnyStyleBox {
     }
 }
 
-private class StyleBox<Base: SliderStyle>: AnyStyleBox {
+private final class StyleBox<Base: SliderStyle>: AnyStyleBox {
     let base: Base
 
     init(base: Base) {
diff --git a/Sources/OpenSwiftUI/Data/Environment/Internal/EnvironmentValues+sliderStyle.swift b/Sources/OpenSwiftUI/View/Control/Slider/SliderStyleKey.swift
similarity index 84%
rename from Sources/OpenSwiftUI/Data/Environment/Internal/EnvironmentValues+sliderStyle.swift
rename to Sources/OpenSwiftUI/View/Control/Slider/SliderStyleKey.swift
index 9ef61e82..108593aa 100644
--- a/Sources/OpenSwiftUI/Data/Environment/Internal/EnvironmentValues+sliderStyle.swift
+++ b/Sources/OpenSwiftUI/View/Control/Slider/SliderStyleKey.swift
@@ -1,9 +1,10 @@
 //
-//  EnvironmentValues+sliderStyle.swift
+//  SliderStyleKey.swift
 //  OpenSwiftUI
 //
 //  Audited for RELEASE_2021
 //  Status: Complete
+//  ID: F0F8A8741F68A968D995328632123C18
 
 private struct SliderStyleKey: EnvironmentKey {
     static let defaultValue = AnySliderStyle.default
diff --git a/Sources/OpenSwiftUI/View/Control/Slider/internal/SystemSliderStyle.swift b/Sources/OpenSwiftUI/View/Control/Slider/SystemSliderStyle.swift
similarity index 100%
rename from Sources/OpenSwiftUI/View/Control/Slider/internal/SystemSliderStyle.swift
rename to Sources/OpenSwiftUI/View/Control/Slider/SystemSliderStyle.swift
diff --git a/Sources/OpenSwiftUI/View/Core/Debug/TODO/ViewDebug.swift b/Sources/OpenSwiftUI/View/Core/Debug/TODO/ViewDebug.swift
index 81ff2930..c2a582c0 100644
--- a/Sources/OpenSwiftUI/View/Core/Debug/TODO/ViewDebug.swift
+++ b/Sources/OpenSwiftUI/View/Core/Debug/TODO/ViewDebug.swift
@@ -56,16 +56,16 @@ extension _ViewDebug {
             self.rawValue = rawValue
         }
 
-        public static let type = Property(rawValue: 1 << Property.type.rawValue)
-        public static let value = Property(rawValue: 1 << Property.value.rawValue)
-        public static let transform = Property(rawValue: 1 << Property.transform.rawValue)
-        public static let position = Property(rawValue: 1 << Property.position.rawValue)
-        public static let size = Property(rawValue: 1 << Property.size.rawValue)
-        public static let environment = Property(rawValue: 1 << Property.environment.rawValue)
-        public static let phase = Property(rawValue: 1 << Property.phase.rawValue)
-        public static let layoutComputer = Property(rawValue: 1 << Property.layoutComputer.rawValue)
-        public static let displayList = Property(rawValue: 1 << Property.displayList.rawValue)
-        public static let all = Property(rawValue: 0xFFFF_FFFF)
+        public static let type = Properties(rawValue: 1 << Property.type.rawValue)
+        public static let value = Properties(rawValue: 1 << Property.value.rawValue)
+        public static let transform = Properties(rawValue: 1 << Property.transform.rawValue)
+        public static let position = Properties(rawValue: 1 << Property.position.rawValue)
+        public static let size = Properties(rawValue: 1 << Property.size.rawValue)
+        public static let environment = Properties(rawValue: 1 << Property.environment.rawValue)
+        public static let phase = Properties(rawValue: 1 << Property.phase.rawValue)
+        public static let layoutComputer = Properties(rawValue: 1 << Property.layoutComputer.rawValue)
+        public static let displayList = Properties(rawValue: 1 << Property.displayList.rawValue)
+        public static let all = Properties(rawValue: 0xFFFF_FFFF)
     }
 }