Update documentation to match OpenSwiftUI docc format

- Replace markdown code fences with indented code blocks (4 spaces)
- Update main documentation categories (Architecture -> Essentials)
- Follow OpenSwiftUI documentation patterns and conventions
- Maintain consistent formatting across all swift-docc files

Author: Kyle-Ye

.claude/settings.local.json

@@ -0,0 +1,7 @@
+{
+  "permissions": {
+    "additionalDirectories": [
+      "/Users/kyle/Workspace/OpenSwiftUIProject/OpenSwiftUI/Sources/OpenSwiftUI/OpenSwiftUI.docc/"
+    ]
+  }
+}

Sources/OpenAttributeGraph/Attribute/Attribute/Attribute.swift

@@ -5,12 +5,10 @@ public import OpenAttributeGraphCxx
 /// `Attribute` is the core building block of the OpenAttributeGraph reactive system. When you wrap a property 
 /// with `@Attribute`, it becomes reactive and can automatically track dependencies and propagate changes.
 ///
-/// ```swift
-/// @Attribute var count: Int = 0
-/// @Attribute var doubledCount: Int = count * 2
-/// 
-/// count = 5 // doubledCount automatically becomes 10
-/// ```
+///     @Attribute var count: Int = 0
+///     @Attribute var doubledCount: Int = count * 2
+///     
+///     count = 5 // doubledCount automatically becomes 10
 ///
 /// ## Key Features
 ///
@@ -24,44 +22,38 @@ public import OpenAttributeGraphCxx
 ///
 /// Use `@Attribute` to make any Swift value reactive:
 ///
-/// ```swift
-/// struct CounterView {
-///     @Attribute var count: Int = 0
-///     
-///     var body: some View {
-///         Button("Count: \(count)") {
-///             count += 1
+///     struct CounterView {
+///         @Attribute var count: Int = 0
+///         
+///         var body: some View {
+///             Button("Count: \(count)") {
+///                 count += 1
+///             }
 ///         }
 ///     }
-/// }
-/// ```
 ///
 /// ## Dynamic Member Lookup
 ///
 /// Access nested properties as separate attributes:
 ///
-/// ```swift
-/// @Attribute var person: Person = Person(name: "Alice", age: 30)
-/// let nameAttribute: Attribute<String> = person.name
-/// let ageAttribute: Attribute<Int> = person.age
-/// ```
+///     @Attribute var person: Person = Person(name: "Alice", age: 30)
+///     let nameAttribute: Attribute<String> = person.name
+///     let ageAttribute: Attribute<Int> = person.age
 ///
 /// ## Integration with Rules
 ///
 /// Create computed attributes using ``Rule`` or ``StatefulRule``:
 ///
-/// ```swift
-/// struct DoubledRule: Rule {
-///     typealias Value = Int
-///     let source: Attribute<Int>
-///     
-///     func value() -> Int {
-///         source.wrappedValue * 2
+///     struct DoubledRule: Rule {
+///         typealias Value = Int
+///         let source: Attribute<Int>
+///         
+///         func value() -> Int {
+///             source.wrappedValue * 2
+///         }
 ///     }
-/// }
 ///
-/// let doubled = Attribute(DoubledRule(source: count))
-/// ```
+///     let doubled = Attribute(DoubledRule(source: count))
 @frozen
 @propertyWrapper
 @dynamicMemberLookup
@@ -89,9 +81,7 @@ public struct Attribute<Value> {
     /// This initializer creates an external attribute that holds the provided value.
     /// External attributes are typically used for storing user input or initial state.
     ///
-    /// ```swift
-    /// let count = Attribute(value: 42)
-    /// ```
+    ///     let count = Attribute(value: 42)
     ///
     /// - Parameter value: The initial value for the attribute
     public init(value: Value) {
@@ -145,12 +135,10 @@ public struct Attribute<Value> {
     /// Getting this value may trigger dependency tracking in the current evaluation context.
     /// Setting this value will update the attribute and invalidate any dependents.
     ///
-    /// ```swift
-    /// @Attribute var count: Int = 0
-    /// 
-    /// print(count) // Gets wrappedValue, returns 0
-    /// count = 5    // Sets wrappedValue, triggers updates
-    /// ```
+    ///     @Attribute var count: Int = 0
+    ///     
+    ///     print(count) // Gets wrappedValue, returns 0
+    ///     count = 5    // Sets wrappedValue, triggers updates
     public var wrappedValue: Value {
         unsafeAddress {
             OAGGraphGetValue(identifier, type: Value.self)
@@ -166,12 +154,10 @@ public struct Attribute<Value> {
     /// allowing you to pass the reactive attribute to other functions or create
     /// derived attributes.
     ///
-    /// ```swift
-    /// @Attribute var count: Int = 0
-    /// 
-    /// let countAttribute = $count  // Gets the Attribute<Int> object
-    /// let doubled = countAttribute.map { $0 * 2 }
-    /// ```
+    ///     @Attribute var count: Int = 0
+    ///     
+    ///     let countAttribute = $count  // Gets the Attribute<Int> object
+    ///     let doubled = countAttribute.map { $0 * 2 }
     public var projectedValue: Attribute<Value> {
         get { self }
         set { self = newValue }

Sources/OpenAttributeGraph/Attribute/Rule/Rule.swift

@@ -12,23 +12,21 @@ public import OpenAttributeGraphCxx
 /// Rules provide a way to create derived attributes that compute their values based on other attributes.
 /// When any dependency changes, the rule will automatically recompute its value.
 ///
-/// ```swift
-/// struct DoubledRule: Rule {
-///     typealias Value = Int
-///     let source: Attribute<Int>
-///     
-///     var value: Int {
-///         source.wrappedValue * 2
+///     struct DoubledRule: Rule {
+///         typealias Value = Int
+///         let source: Attribute<Int>
+///         
+///         var value: Int {
+///             source.wrappedValue * 2
+///         }
 ///     }
-/// }
 ///
-/// @Attribute var count: Int = 5
-/// let doubled = Attribute(DoubledRule(source: $count))
-/// // doubled.wrappedValue == 10
+///     @Attribute var count: Int = 5
+///     let doubled = Attribute(DoubledRule(source: $count))
+///     // doubled.wrappedValue == 10
 ///
-/// count = 10
-/// // doubled.wrappedValue automatically becomes 20
-/// ```
+///     count = 10
+///     // doubled.wrappedValue automatically becomes 20
 ///
 /// ## Key Features
 ///
@@ -65,12 +63,10 @@ public protocol Rule: _AttributeBody {
     /// the result. The attribute graph will automatically track these dependencies and
     /// invalidate this rule when any dependency changes.
     ///
-    /// ```swift
-    /// var value: Int {
-    ///     // Dependencies are automatically tracked
-    ///     return source1.wrappedValue + source2.wrappedValue
-    /// }
-    /// ```
+    ///     var value: Int {
+    ///         // Dependencies are automatically tracked
+    ///         return source1.wrappedValue + source2.wrappedValue
+    ///     }
     var value: Value { get }
 }
 

Sources/OpenAttributeGraph/OpenAttributeGraph.docc/Architecture.md

@@ -16,24 +16,20 @@ The **Attribute layer** forms the foundation of the reactive system, providing t
 
 **Property Wrapper Design**: At its heart, ``Attribute`` is a property wrapper that makes any Swift value reactive. When you wrap a value with `@Attribute`, it automatically gains dependency tracking capabilities:
 
-```swift
-@Attribute var count: Int = 0
-```
+    @Attribute var count: Int = 0
 
 **Type Erasure**: ``AnyAttribute`` provides type-erased access to attributes, enabling runtime flexibility while maintaining type safety where possible.
 
 **Rule-Based Transformations**: The ``Rule`` and ``StatefulRule`` protocols allow you to create computed attributes that automatically update when their dependencies change:
 
-```swift
-struct DoubledRule: Rule {
-    typealias Value = Int
-    let source: Attribute<Int>
-    
-    func value() -> Int {
-        source.wrappedValue * 2
+    struct DoubledRule: Rule {
+        typealias Value = Int
+        let source: Attribute<Int>
+        
+        func value() -> Int {
+            source.wrappedValue * 2
+        }
     }
-}
-```
 
 **Reference Semantics**: ``WeakAttribute`` and ``OptionalAttribute`` provide safe ways to handle optional and weak references within the attribute system.
 
@@ -84,10 +80,8 @@ The **Runtime layer** provides the low-level type introspection and memory manag
 
 This runtime introspection enables features like automatic KeyPath-based attribute access:
 
-```swift
-@Attribute var person: Person = Person(name: "Alice", age: 30)
-let nameAttribute = person.name  // Automatic attribute creation via KeyPath
-```
+    @Attribute var person: Person = Person(name: "Alice", age: 30)
+    let nameAttribute = person.name  // Automatic attribute creation via KeyPath
 
 #### Memory Management
 

Sources/OpenAttributeGraph/OpenAttributeGraph.docc/OpenAttributeGraph.md

@@ -10,7 +10,7 @@ The framework is designed for high performance and powers the reactive updates t
 
 ## Topics
 
-### Architecture
+### Essentials
 
 - <doc:Architecture-article>
 
@@ -56,4 +56,4 @@ The framework is designed for high performance and powers the reactive updates t
 
 #### Type System Support
 - ``External``
-- ``PointerOffset``
+- ``PointerOffset``

Sources/OpenAttributeGraph/Runtime/Metadata.swift

@@ -36,10 +36,8 @@ extension Metadata: Swift.Hashable, Swift.CustomStringConvertible {
     /// This initializer allows you to create runtime metadata for any Swift type,
     /// which can then be used for type introspection and comparison.
     ///
-    /// ```swift
-    /// let intMetadata = Metadata(Int.self)
-    /// let stringMetadata = Metadata(String.self)
-    /// ```
+    ///     let intMetadata = Metadata(Int.self)
+    ///     let stringMetadata = Metadata(String.self)
     ///
     /// - Parameter type: The Swift type to create metadata for
     public init(_ type: any Any.Type) {
@@ -51,10 +49,8 @@ extension Metadata: Swift.Hashable, Swift.CustomStringConvertible {
     /// This property allows you to convert from runtime metadata back to a Swift type,
     /// enabling dynamic type operations.
     ///
-    /// ```swift
-    /// let metadata = Metadata(String.self)
-    /// let type = metadata.type // Returns String.Type
-    /// ```
+    ///     let metadata = Metadata(String.self)
+    ///     let type = metadata.type // Returns String.Type
     public var type: any Any.Type {
         unsafeBitCast(rawValue, to: Any.Type.self)
     }