visionOS Object Tracking Enhancements

 import ARKit
 import RealityKit
+import SwiftUI
 
−// Pre-iOS 27 / visionOS 26: Object tracking visionOS only, no metric-space API
−// No high frame rate config, no coordinate space correction option
+// MARK: - visionOS: High Frame Rate + Metric Pose
 
−@available(visionOS 2, *)
−class LegacyObjectTrackingManager: ObservableObject {
+@available(visionOS 27, *)
+class ObjectTrackingManager: ObservableObject {
     private var arkitSession = ARKitSession()
+    private var objectTracking: ObjectTrackingProvider?
 
+    @Published var metricPosition: SIMD3<Float> = .zero
+
     func startTracking() async throws {
         guard let referenceObjectURL = Bundle.main.url(
             forResource: "flashlight",
             withExtension: "referenceobject"
         ) else { return }
 
−        // No ReferenceObjectConfiguration — loaded without high frame rate option
−        let referenceObject = try await ReferenceObject(from: referenceObjectURL)
+        // Load reference object with high frame rate config
+        let config = ReferenceObjectConfiguration()
+        config.isHighFrameRateTrackingEnabled = true
 
+        let referenceObject = try await ReferenceObject(
+            from: referenceObjectURL,
+            configuration: config
+        )
+
         let provider = ObjectTrackingProvider(referenceObjects: [referenceObject])
+        self.objectTracking = provider
 
         try await arkitSession.run([provider])
 
+        // Process anchor updates
         for await update in provider.anchorUpdates {
             let anchor = update.anchor
             guard anchor.isTracked else { continue }
 
−            // Only one transform available — always display-corrected, no metric option
−            let transform = anchor.originFromAnchorTransform
−            let position = SIMD3(
−                transform.columns.3.x,
−                transform.columns.3.y,
−                transform.columns.3.z
−            )
−            print("Object position (display-corrected only): \(position)")
+            switch update.event {
+            case .added, .updated:
+                // Use .none correction for metric space (measuring)
+                let metricTransform = anchor.originFromAnchorTransform(
+                    coordinateSpaceCorrection: .none
+                )
+                await MainActor.run {
+                    self.metricPosition = SIMD3(
+                        metricTransform.columns.3.x,
+                        metricTransform.columns.3.y,
+                        metricTransform.columns.3.z
+                    )
+                }
+            case .removed:
+                await MainActor.run { self.metricPosition = .zero }
+            }
         }
     }
 }
 
−// iOS: Object tracking was NOT available at all before iOS 27
−// ARWorldTrackingConfiguration had no detectionObjects or trackingObjects on iOS
+// MARK: - iOS 27: ARKit Object Tracking
+
+@available(iOS 27, *)
+class iOSObjectTrackingDelegate: NSObject, ARSessionDelegate {
+    func setupSession() -> ARSession {
+        let session = ARSession()
+        session.delegate = self
+
+        let config = ARWorldTrackingConfiguration()
+
+        if let referenceObjects = ARReferenceObject.referenceObjects(
+            inGroupNamed: "AR Resources",
+            bundle: .main
+        ) {
+            // stationary objects
+            config.detectionObjects = referenceObjects
+            // OR for moving/handheld objects:
+            // config.trackingObjects = referenceObjects
+        }
+
+        session.run(config)
+        return session
+    }
+
+    func session(_ session: ARSession, didAdd anchors: [ARAnchor]) {
+        for anchor in anchors.compactMap({ $0 as? ARObjectAnchor }) {
+            print("Detected: \(anchor.referenceObject.name ?? "unknown")")
+            // Attach RealityKit content to anchor.transform
+        }
+    }
+
+    func session(_ session: ARSession, didUpdate anchors: [ARAnchor]) {
+        for anchor in anchors.compactMap({ $0 as? ARObjectAnchor }) {
+            let pos = anchor.transform.columns.3
+            print("Updated position: (\(pos.x), \(pos.y), \(pos.z))")
+        }
+    }
+
+    func session(_ session: ARSession, didRemove anchors: [ARAnchor]) {
+        for anchor in anchors.compactMap({ $0 as? ARObjectAnchor }) {
+            print("Lost tracking: \(anchor.referenceObject.name ?? "unknown")")
+        }
+    }
+}