Add comprehensive DocC documentation for Swift APIs

Extension files created:
- StatefulRule.md - Stateful computed attributes with mutable state
- WeakAttribute.md - Weak reference attributes preventing retain cycles
- Graph.md - Central dependency coordinator and update management
- Subgraph.md - Scoped computation contexts for isolation
- RuleContext.md - Rule evaluation context and input access
- Focus.md - KeyPath-based property focusing rules

Source documentation added:
- StatefulRule.swift - Brief protocol description
- WeakAttribute.swift - Weak reference property wrapper docs
- OptionalAttribute.swift - Optional attribute wrapper docs
- Focus.swift - KeyPath focusing rule docs
- RuleContext.swift - Evaluation context docs
- CompareValues.swift - Value comparison function docs

All APIs now have proper DocC documentation following OpenSwiftUI patterns

Author: Kyle-Ye

.spi.yml

@@ -1,5 +1,4 @@
 version: 1
 builder:
   configs:
-    - swift_version: 6.0
-      documentation_targets: [OpenAttributeGraph]
+    - documentation_targets: [OpenAttributeGraph]

Sources/OpenAttributeGraph/Attribute/Optional/OptionalAttribute.swift

@@ -5,6 +5,7 @@
 //  Audited for RELEASE_2021
 //  Status: Complete
 
+/// An optional attribute wrapper that may or may not contain a value.
 @frozen
 @propertyWrapper
 @dynamicMemberLookup

Sources/OpenAttributeGraph/Attribute/Rule/Focus.swift

@@ -5,6 +5,7 @@
 //  Audited for RELEASE_2021
 //  Status: Complete
 
+/// A rule that focuses on a specific property of another attribute using KeyPath.
 @frozen
 public struct Focus<Root, Value>: Rule, CustomStringConvertible {
     public var root: Attribute<Root>

Sources/OpenAttributeGraph/Attribute/Rule/StatefulRule.swift

@@ -7,6 +7,7 @@
 
 public import OpenAttributeGraphCxx
 
+/// A protocol for defining computed attributes that maintain state between evaluations.
 public protocol StatefulRule: _AttributeBody {
     associatedtype Value
     static var initialValue: Value? { get }

Sources/OpenAttributeGraph/Attribute/RuleContext/RuleContext.swift

@@ -7,6 +7,7 @@
 
 public import OpenAttributeGraphCxx
 
+/// Context object providing access to rule evaluation state and input values.
 @frozen
 public struct RuleContext<Value>: Equatable {
     public var attribute: Attribute<Value>

Sources/OpenAttributeGraph/Attribute/Weak/WeakAttribute.swift

@@ -7,6 +7,7 @@
 
 public import OpenAttributeGraphCxx
 
+/// A weak reference property wrapper for attributes that prevents retain cycles.
 @frozen
 @propertyWrapper
 @dynamicMemberLookup

Sources/OpenAttributeGraph/OpenAttributeGraph.docc/Focus.md

@@ -0,0 +1,49 @@
+# ``Focus``
+
+A rule that focuses on a specific property of another attribute using KeyPath.
+
+## Overview
+
+`Focus` provides a way to create attributes that automatically track a specific property of another attribute. It uses Swift's KeyPath system to create a focused view of part of a larger data structure.
+
+    struct Person {
+        let name: String
+        let age: Int
+    }
+
+    @Attribute var person = Person(name: "Alice", age: 30)
+    let nameAttribute = Attribute(Focus(root: $person, keyPath: \.name))
+    // nameAttribute automatically updates when person.name changes
+
+Focus is commonly used internally by OpenAttributeGraph's dynamic member lookup system to create property-specific attributes.
+
+## Key Features
+
+- KeyPath-based focusing: Use any Swift KeyPath to focus on specific properties
+- Automatic updates: Changes to the focused property automatically propagate
+- Type safety: Full compile-time type checking for focused properties
+- Efficient tracking: Only tracks changes to the specific focused property
+
+## Usage Pattern
+
+Focus is ideal for:
+- Creating focused views of complex data structures
+- Implementing dynamic member lookup for attributes
+- Breaking down large objects into smaller, more manageable attribute pieces
+- Selective observation of specific properties
+
+## Topics
+
+### Creating Focus Rules
+
+- ``init(root:keyPath:)``
+
+### Properties
+
+- ``root``
+- ``keyPath``
+- ``value``
+
+### Configuration
+
+- ``flags``

Sources/OpenAttributeGraph/OpenAttributeGraph.docc/Graph.md

@@ -0,0 +1,60 @@
+# ``Graph``
+
+The central coordinator for attribute relationships and update cycles.
+
+## Overview
+
+`Graph` manages the dependency network between attributes and orchestrates efficient updates across the entire reactive system. It maintains a directed acyclic graph (DAG) of attribute dependencies and handles the propagation of changes.
+
+The graph automatically tracks dependencies when attributes are accessed during rule evaluation, detects cycles, and batches updates for optimal performance.
+
+## Key Features
+
+- Dependency tracking: Automatically discovers and maintains attribute relationships
+- Cycle detection: Prevents and detects circular dependencies
+- Batch updates: Groups multiple changes for efficient processing
+- Update scheduling: Coordinates when and how attributes are recomputed
+- Performance monitoring: Profiling and debugging capabilities
+
+## Update Propagation
+
+When an attribute changes, the graph efficiently propagates updates through three phases:
+1. Mark phase: Changed attributes are marked as invalid
+2. Sweep phase: Dependent attributes are transitively marked  
+3. Update phase: Values are recomputed in dependency order
+
+## Topics
+
+### Update Control
+
+- ``withoutUpdate(_:)``
+- ``withoutSubgraphInvalidation(_:)``
+- ``withDeadline(_:_:)``
+
+### Callbacks
+
+- ``onInvalidation(_:)``
+- ``onUpdate(_:)``
+
+### Performance Monitoring
+
+- ``startProfiling()``
+- ``stopProfiling()``
+- ``resetProfile()``
+
+### Statistics
+
+- ``mainUpdates``
+
+### Global Operations
+
+- ``anyInputsChanged(excluding:)``
+
+### Output Management
+
+- ``outputValue()``
+- ``setOutputValue(_:)``
+
+### Archive and Debug
+
+- ``archiveJSON(name:)``

Sources/OpenAttributeGraph/OpenAttributeGraph.docc/RuleContext.md

@@ -0,0 +1,55 @@
+# ``RuleContext``
+
+Context object providing access to rule evaluation state and input values.
+
+## Overview
+
+`RuleContext` provides a structured way to access input values and manage state during rule evaluation. It offers type-safe access to dependent attributes and their values within the context of a specific rule execution.
+
+The context ensures that dependency tracking is properly maintained while providing convenient access to input attributes.
+
+## Key Features
+
+- Type-safe input access: Access dependent attribute values with full type safety
+- Dependency tracking: Automatically tracks accessed attributes as dependencies
+- Value management: Direct access to current and changed values
+- Context isolation: Maintains evaluation context for proper dependency resolution
+
+## Usage in Rules
+
+RuleContext is typically used within ``StatefulRule`` implementations to access dependencies and manage the rule's output value:
+
+    struct MyRule: StatefulRule {
+        let inputAttribute: Attribute<Int>
+        
+        mutating func updateValue() {
+            let inputValue = context[inputAttribute]
+            value = inputValue * 2
+        }
+    }
+
+## Topics
+
+### Creating Context
+
+- ``init(attribute:)``
+
+### Input Access
+
+- ``subscript(_:)-1g3wa``
+- ``subscript(_:)-6y4wa``
+- ``subscript(_:)-2h8nh``
+
+### Value Management
+
+- ``value``
+- ``hasValue``
+
+### Change Tracking
+
+- ``changedValueFlagged(options:)``
+- ``wasModified(options:)``
+
+### Associated Attribute
+
+- ``attribute``

Sources/OpenAttributeGraph/OpenAttributeGraph.docc/StatefulRule.md

@@ -0,0 +1,52 @@
+# ``StatefulRule``
+
+A protocol for defining computed attributes that maintain state between evaluations.
+
+## Overview
+
+`StatefulRule` extends the basic `Rule` concept by allowing rules to maintain mutable state between updates. This is useful for rules that need to track changes over time or maintain internal state.
+
+    struct CounterRule: StatefulRule {
+        typealias Value = Int
+        private var counter = 0
+        
+        mutating func updateValue() {
+            counter += 1
+            value = counter
+        }
+    }
+
+Unlike ``Rule``, `StatefulRule` allows mutation through the `updateValue()` method and provides direct access to the current value through the `value` property.
+
+## Key Features
+
+- Mutable state: Rules can maintain and modify internal state
+- Direct value access: Read and write the current value directly
+- Context access: Access to rule evaluation context and attribute
+- Lifecycle control: Manual control over when and how values update
+
+## Usage Pattern
+
+StatefulRule is ideal for scenarios where you need to:
+- Accumulate values over time
+- Maintain counters or timers
+- Implement complex state machines
+- Cache expensive computations with custom invalidation
+
+## Topics
+
+### Protocol Requirements
+
+- ``Value``
+- ``initialValue``
+- ``updateValue()``
+
+### Value Management
+
+- ``value``
+- ``hasValue``
+
+### Context Access
+
+- ``attribute``
+- ``context``