feat: Overlay the mathematical Sun Path over the live camera feed or 3D model view (#8)

#7 Task completed.

Co-authored-by: Sayan Datta <sayan@Sayans-MacBook-Air.local>
Reviewed-on: sagnik/Project_Velocity#8

iOS/velocity/velocity/Core/Config/AppConfig.swift

@@ -11,6 +11,6 @@ enum AppConfig {
            !override.isEmpty, override != "$(BASE_URL)" {
             return override
         }
-        return "http://54.172.172.2:8080"
+        return "http://54.91.19.60:8082"
     }()
 }

iOS/velocity/velocity/Core/Math/SunMath.swift

@@ -2,11 +2,14 @@ import CoreLocation
 import Foundation
 
 struct SunPosition {
-    let azimuth: Double // 0...360, degrees clockwise from true north
+    let azimuth: Double   // 0...360, degrees clockwise from true north
     let elevation: Double // -90...90 degrees above horizon
 }
 
 enum SunMath {
+
+    // MARK: - Single Position
+
     static func calculateSunPosition(date: Date, coordinate: CLLocationCoordinate2D) -> SunPosition {
         let timezone = TimeZone.current
         let localOffsetHours = Double(timezone.secondsFromGMT(for: date)) / 3600.0
@@ -14,7 +17,7 @@ enum SunMath {
 
         let n = julianDay - 2_451_545.0
         let meanLongitude = normalizeDegrees(280.46 + 0.985_647_4 * n)
-        let meanAnomaly = normalizeDegrees(357.528 + 0.985_600_3 * n)
+        let meanAnomaly   = normalizeDegrees(357.528 + 0.985_600_3 * n)
 
         let lambda = meanLongitude
             + 1.915 * sin(meanAnomaly.radians)
@@ -32,9 +35,9 @@ enum SunMath {
         let hourAngle = normalizeDegrees(lst - rightAscension)
         let signedHourAngle = hourAngle > 180.0 ? hourAngle - 360.0 : hourAngle
 
-        let latitude = coordinate.latitude.radians
+        let latitude       = coordinate.latitude.radians
         let declinationRad = declination.radians
-        let hourAngleRad = signedHourAngle.radians
+        let hourAngleRad   = signedHourAngle.radians
 
         let elevation = asin(
             sin(latitude) * sin(declinationRad)
@@ -51,11 +54,13 @@ enum SunMath {
         return SunPosition(azimuth: azimuth, elevation: elevation)
     }
 
+    // MARK: - Hourly Arc (used by legacy code & DashedSunLine)
+
+    /// 5-sample dictionary kept for backward compat with the Dollhouse slider.
     static func sunPathSamples(for date: Date, coordinate: CLLocationCoordinate2D) -> [Date: SunPosition] {
         let calendar = Calendar.current
         let sampleHours = [8, 10, 12, 14, 16]
         var output: [Date: SunPosition] = [:]
-
         for hour in sampleHours {
             if let sampleDate = calendar.date(bySettingHour: hour, minute: 0, second: 0, of: date) {
                 output[sampleDate] = calculateSunPosition(date: sampleDate, coordinate: coordinate)
@@ -64,25 +69,62 @@ enum SunMath {
         return output
     }
 
-    private static func normalizeDegrees(_ value: Double) -> Double {
+    /// Dense arc for the AR overlay — one sample per hour from 4 AM to 8 PM.
+    /// Filters out below-horizon positions (elevation < -5°).
+    static func sunPathArc(for date: Date, coordinate: CLLocationCoordinate2D) -> [(date: Date, position: SunPosition)] {
+        let calendar = Calendar.current
+        var result: [(Date, SunPosition)] = []
+        for hour in 4...20 {
+            guard let sampleDate = calendar.date(bySettingHour: hour, minute: 0, second: 0, of: date) else { continue }
+            let pos = calculateSunPosition(date: sampleDate, coordinate: coordinate)
+            // include a small below-horizon buffer so arc starts/ends smoothly
+            if pos.elevation > -5 {
+                result.append((sampleDate, pos))
+            }
+        }
+        return result
+    }
+
+    /// Approximate sunrise and sunset by scanning for elevation sign changes.
+    static func sunRiseSet(for date: Date, coordinate: CLLocationCoordinate2D) -> (rise: Date?, set: Date?) {
+        let calendar = Calendar.current
+        var rise: Date? = nil
+        var set: Date? = nil
+        var prevElevation: Double? = nil
+        var prevDate: Date? = nil
+
+        for minuteOffset in stride(from: 0, through: 24 * 60, by: 10) {
+            guard let sampleDate = calendar.date(byAdding: .minute, value: minuteOffset, to: calendar.startOfDay(for: date)) else { continue }
+            let pos = calculateSunPosition(date: sampleDate, coordinate: coordinate)
+            if let prev = prevElevation, let prevD = prevDate {
+                if prev < 0 && pos.elevation >= 0 { rise = prevD }
+                if prev >= 0 && pos.elevation < 0 { set = prevD }
+            }
+            prevElevation = pos.elevation
+            prevDate = sampleDate
+        }
+        return (rise, set)
+    }
+
+    // MARK: - Helpers
+
+    static func normalizeDegrees(_ value: Double) -> Double {
         let reduced = value.truncatingRemainder(dividingBy: 360.0)
         return reduced >= 0 ? reduced : reduced + 360.0
     }
 }
 
+// MARK: - Date helpers
+
 private extension Date {
     var utcHours: Double {
         let calendar = Calendar(identifier: .gregorian)
         let comps = calendar.dateComponents(in: TimeZone(secondsFromGMT: 0)!, from: self)
-        let hours = Double(comps.hour ?? 0)
-        let minutes = Double(comps.minute ?? 0)
-        let seconds = Double(comps.second ?? 0)
-        return hours + minutes / 60.0 + seconds / 3600.0
+        return Double(comps.hour ?? 0) + Double(comps.minute ?? 0) / 60.0 + Double(comps.second ?? 0) / 3600.0
     }
 
     var julianDay: Double {
-        let interval = timeIntervalSince1970
-        return (interval / 86_400.0) + 2_440_587.5
+        timeIntervalSince1970 / 86_400.0 + 2_440_587.5
     }
 }
 

iOS/velocity/velocity/Core/Networking/ComfyClient.swift

@@ -17,7 +17,9 @@ final class ComfyClient {
     /// Returns `true` if `{ "status": "ok" }`.
     func checkHealth() async -> Bool {
         guard let url = URL(string: "\(baseURL)/health") else { return false }
-        guard let (data, _) = try? await URLSession.shared.data(from: url),
+        var request = URLRequest(url: url)
+        request.timeoutInterval = 30.0
+        guard let (data, _) = try? await URLSession.shared.data(for: request),
               let json = try? JSONDecoder().decode(HealthResponse.self, from: data) else {
             return false
         }
@@ -30,9 +32,9 @@ final class ComfyClient {
     /// Full pipeline: upload → queue → poll → download.
     /// - Parameters:
     ///   - source: Room photo from camera or library.
-    ///   - style: One of `scandinavian`, `art_deco`, `biophilic`, `cyberpunk`, `japandi`.
+    ///   - roomType: The type of room being designed (e.g. "bedroom", "living_room").
     ///   - keywords: Comma-separated user keywords appended to the style prompt (can be empty).
-    func generateImage(source: UIImage, style: String, keywords: String) async throws -> UIImage {
+    func generateImage(source: UIImage, roomType: String, keywords: String) async throws -> UIImage {
         let normalised = source.fixedOrientation()
         let resized    = normalised.resizedSquare(to: 1024)
         guard let imageData = resized.jpegData(compressionQuality: 0.85) else {
@@ -40,7 +42,7 @@ final class ComfyClient {
         }
 
         // 1. Submit job → get job_id
-        let job = try await submitJob(imageData: imageData, style: style, keywords: keywords)
+        let job = try await submitJob(imageData: imageData, roomType: roomType, keywords: keywords)
 
         // 2. Poll status every 2s until ready (max 5 min per integration guide §3.3)
         let resultURL = try await pollUntilReady(jobId: job.jobId)
@@ -51,7 +53,7 @@ final class ComfyClient {
 
     // MARK: - Step 1: POST /dream-weaver
 
-    private func submitJob(imageData: Data, style: String, keywords: String) async throws -> GenerationJob {
+    private func submitJob(imageData: Data, roomType: String, keywords: String) async throws -> GenerationJob {
         guard let url = URL(string: "\(baseURL)/dream-weaver") else {
             throw DreamWeaverError.generationFailed("Invalid gateway URL")
         }
@@ -60,9 +62,10 @@ final class ComfyClient {
         var request = URLRequest(url: url)
         request.httpMethod = "POST"
         request.setValue("multipart/form-data; boundary=\(boundary)", forHTTPHeaderField: "Content-Type")
+        request.timeoutInterval = 180.0
         request.httpBody = buildMultipart(
             imageData: imageData,
-            style: style,
+            roomType: roomType,
             keywords: keywords,
             boundary: boundary
         )
@@ -110,7 +113,7 @@ final class ComfyClient {
 
     // MARK: - Multipart Builder
 
-    private func buildMultipart(imageData: Data, style: String, keywords: String, boundary: String) -> Data {
+    private func buildMultipart(imageData: Data, roomType: String, keywords: String, boundary: String) -> Data {
         var body = Data()
         let crlf = "\r\n"
 
@@ -121,10 +124,10 @@ final class ComfyClient {
         body += imageData
         body += crlf
 
-        // style field — must be one of the 5 preset IDs
+        // roomType field
         body += "--\(boundary)\(crlf)"
-        body += "Content-Disposition: form-data; name=\"style\"\(crlf)\(crlf)"
-        body += style
+        body += "Content-Disposition: form-data; name=\"room_type\"\(crlf)\(crlf)"
+        body += roomType
         body += crlf
 
         // keywords field — user's optional comma-separated additions

iOS/velocity/velocity/Features/Inventory/ARSunOverlayView.swift

@@ -4,11 +4,14 @@ import CoreMotion
 import SceneKit
 import SwiftUI
 
+// MARK: - ARSunOverlayView
+
 struct ARSunOverlayView: UIViewRepresentable {
     @Binding var sunNodesReady: Bool
+    let vm: SunseekerViewModel
 
     func makeCoordinator() -> Coordinator {
-        Coordinator(sunNodesReady: $sunNodesReady)
+        Coordinator(sunNodesReady: $sunNodesReady, vm: vm)
     }
 
     func makeUIView(context: Context) -> ARSCNView {
@@ -18,7 +21,7 @@ struct ARSunOverlayView: UIViewRepresentable {
         view.automaticallyUpdatesLighting = true
 
         let config = ARWorldTrackingConfiguration()
-        config.worldAlignment = .gravityAndHeading
+        config.worldAlignment = .gravityAndHeading  // north = -Z axis
         view.session.run(config)
 
         context.coordinator.attach(to: view)
@@ -32,87 +35,242 @@ struct ARSunOverlayView: UIViewRepresentable {
         coordinator.stop()
     }
 
+    // MARK: - Coordinator
+
     final class Coordinator: NSObject, ARSCNViewDelegate, CLLocationManagerDelegate {
-        private let locationManager = CLLocationManager()
-        private let motionManager = CMMotionManager()
+
         private weak var sceneView: ARSCNView?
-        private var heading: CLLocationDirection = 0
-        private var coordinate: CLLocationCoordinate2D?
+        private let vm: SunseekerViewModel
         @Binding private var sunNodesReady: Bool
 
-        init(sunNodesReady: Binding<Bool>) {
+        // Scene node containers (replaced on each rebuild)
+        private var arcRootNode      = SCNNode()
+        private var currentSunNode   = SCNNode()
+        private var isSceneBuilt     = false
+
+        // Fallback timer for CoreMotion-only mode
+        private var fallbackTimer: Timer?
+        private var limitedTrackingStart: Date?
+
+        init(sunNodesReady: Binding<Bool>, vm: SunseekerViewModel) {
             _sunNodesReady = sunNodesReady
-            super.init()
-            locationManager.delegate = self
-            locationManager.desiredAccuracy = kCLLocationAccuracyBest
-            locationManager.headingFilter = 1
-            locationManager.requestWhenInUseAuthorization()
-            locationManager.startUpdatingLocation()
-            locationManager.startUpdatingHeading()
-            startMotion()
+            self.vm = vm
         }
 
         func attach(to sceneView: ARSCNView) {
             self.sceneView = sceneView
-            addSunPathNodesIfPossible()
+            sceneView.scene.rootNode.addChildNode(arcRootNode)
+            sceneView.scene.rootNode.addChildNode(currentSunNode)
         }
 
         func stop() {
-            motionManager.stopDeviceMotionUpdates()
-            locationManager.stopUpdatingHeading()
-            locationManager.stopUpdatingLocation()
+            vm.stop()
+            fallbackTimer?.invalidate()
         }
 
-        func locationManager(_ manager: CLLocationManager, didUpdateLocations locations: [CLLocation]) {
-            guard coordinate == nil, let location = locations.last else { return }
-            coordinate = location.coordinate
-            addSunPathNodesIfPossible()
-        }
+        // MARK: - ARSCNViewDelegate — per-frame update
 
-        func locationManager(_ manager: CLLocationManager, didUpdateHeading newHeading: CLHeading) {
-            heading = newHeading.trueHeading > 0 ? newHeading.trueHeading : newHeading.magneticHeading
-            addSunPathNodesIfPossible()
-        }
+        func renderer(_ renderer: SCNSceneRenderer, updateAtTime time: TimeInterval) {
+            guard vm.isReady else { return }
 
-        private func startMotion() {
-            guard motionManager.isDeviceMotionAvailable else { return }
-            motionManager.deviceMotionUpdateInterval = 0.1
-            motionManager.startDeviceMotionUpdates()
-        }
-
-        private func addSunPathNodesIfPossible() {
-            guard
-                let sceneView,
-                let coordinate,
-                !sunNodesReady
-            else { return }
-
-            let samples = SunMath.sunPathSamples(for: Date(), coordinate: coordinate)
-            let sorted = samples.sorted { $0.key < $1.key }
-            let root = SCNNode()
-            let northOffset = (heading).radians
-            let radius: Float = 1.8
-
-            for (_, pos) in sorted {
-                let elevation = Float(pos.elevation.radians)
-                let azimuth = Float((pos.azimuth).radians) - Float(northOffset)
-                let x = radius * cos(elevation) * sin(azimuth)
-                let y = radius * sin(elevation)
-                let z = -radius * cos(elevation) * cos(azimuth)
-
-                let sphere = SCNSphere(radius: 0.03)
-                sphere.firstMaterial?.diffuse.contents = UIColor.systemYellow
-                let node = SCNNode(geometry: sphere)
-                node.position = SCNVector3(x, y, z)
-                root.addChildNode(node)
+            // Build arc once
+            if !isSceneBuilt {
+                DispatchQueue.main.async { self.buildScene() }
             }
 
-            sceneView.scene.rootNode.addChildNode(root)
+            // Update current sun orb every frame
+            if let cur = vm.currentPosition {
+                let pos = vm.worldPosition(for: cur, radius: 1.8)
+                currentSunNode.position = pos
+            }
+        }
+
+        func session(_ session: ARSession, cameraDidChangeTrackingState camera: ARCamera) {
+            switch camera.trackingState {
+            case .limited(let reason):
+                print("[Sunseeker] Tracking limited: \(reason)")
+                if limitedTrackingStart == nil {
+                    limitedTrackingStart = Date()
+                    // After 5s of limited tracking, switch to CoreMotion attitude fallback
+                    fallbackTimer = Timer.scheduledTimer(withTimeInterval: 5, repeats: false) { [weak self] _ in
+                        self?.activateCoreMotionFallback()
+                    }
+                }
+            case .normal:
+                limitedTrackingStart = nil
+                fallbackTimer?.invalidate()
+                fallbackTimer = nil
+            case .notAvailable:
+                break
+            @unknown default:
+                break
+            }
+        }
+
+        // MARK: - Scene Building
+
+        private func buildScene() {
+            guard let sceneView else { return }
+
+            // Remove old nodes
+            arcRootNode.childNodes.forEach { $0.removeFromParentNode() }
+            currentSunNode.childNodes.forEach { $0.removeFromParentNode() }
+
+            let arc = vm.arc
+            let radius: Float = 1.8
+            var positions: [SCNVector3] = []
+
+            // Hourly marker spheres + time labels
+            for (date, pos) in arc {
+                guard pos.elevation > -5 else { continue }
+                let worldPos = vm.worldPosition(for: pos, radius: radius)
+                positions.append(worldPos)
+
+                let sphere = SCNSphere(radius: 0.018)
+                sphere.firstMaterial?.diffuse.contents = UIColor.systemYellow.withAlphaComponent(0.85)
+                sphere.firstMaterial?.lightingModel = .constant
+                let markerNode = SCNNode(geometry: sphere)
+                markerNode.position = worldPos
+                arcRootNode.addChildNode(markerNode)
+
+                // Time label (only on even hours to avoid clutter)
+                let calendar = Calendar.current
+                let hour = calendar.component(.hour, from: date)
+                if hour % 2 == 0 {
+                    let labelNode = makeTextNode(text: hourLabel(from: date), color: .white, fontSize: 0.04)
+                    labelNode.position = SCNVector3(worldPos.x, worldPos.y + 0.06, worldPos.z)
+                    arcRootNode.addChildNode(labelNode)
+                }
+            }
+
+            // Continuous arc line
+            if positions.count >= 2 {
+                let lineNode = makeLineNode(through: positions, color: UIColor.systemYellow.withAlphaComponent(0.55))
+                arcRootNode.addChildNode(lineNode)
+            }
+
+            // Sunrise marker
+            if let riseDate = vm.riseSet.rise {
+                let risePos = SunMath.calculateSunPosition(date: riseDate, coordinate: vm.coordinate!)
+                let wPos = vm.worldPosition(for: risePos, radius: radius)
+                arcRootNode.addChildNode(makeSpecialMarker(at: wPos, color: .systemOrange, label: "Sunrise \(hourLabel(from: riseDate))"))
+            }
+
+            // Sunset marker
+            if let setDate = vm.riseSet.set {
+                let setPos = SunMath.calculateSunPosition(date: setDate, coordinate: vm.coordinate!)
+                let wPos = vm.worldPosition(for: setPos, radius: radius)
+                arcRootNode.addChildNode(makeSpecialMarker(at: wPos, color: .systemRed, label: "Sunset \(hourLabel(from: setDate))"))
+            }
+
+            // Current sun orb (large, animated glow)
+            if let cur = vm.currentPosition {
+                let orb = SCNSphere(radius: 0.055)
+                orb.firstMaterial?.diffuse.contents   = UIColor.systemOrange
+                orb.firstMaterial?.emission.contents  = UIColor.systemYellow
+                orb.firstMaterial?.lightingModel      = .constant
+                let orbNode = SCNNode(geometry: orb)
+                orbNode.position = vm.worldPosition(for: cur, radius: radius)
+
+                // Pulse animation
+                let pulse = CABasicAnimation(keyPath: "scale")
+                pulse.fromValue  = SCNVector3(1, 1, 1)
+                pulse.toValue    = SCNVector3(1.3, 1.3, 1.3)
+                pulse.duration   = 1.2
+                pulse.autoreverses = true
+                pulse.repeatCount  = .infinity
+                orbNode.addAnimation(pulse, forKey: "pulse")
+
+                let label = makeTextNode(text: "Now", color: .systemYellow, fontSize: 0.05)
+                label.position = SCNVector3(0, 0.09, 0)
+                orbNode.addChildNode(label)
+                currentSunNode.addChildNode(orbNode)
+            }
+
+            isSceneBuilt = true
             sunNodesReady = true
         }
+
+        // MARK: - Node Factories
+
+        private func makeSpecialMarker(at pos: SCNVector3, color: UIColor, label: String) -> SCNNode {
+            let root   = SCNNode()
+            let sphere = SCNSphere(radius: 0.035)
+            sphere.firstMaterial?.diffuse.contents  = color
+            sphere.firstMaterial?.emission.contents = color.withAlphaComponent(0.5)
+            sphere.firstMaterial?.lightingModel     = .constant
+            let markerNode = SCNNode(geometry: sphere)
+            markerNode.position = pos
+            root.addChildNode(markerNode)
+
+            let labelNode = makeTextNode(text: label, color: .white, fontSize: 0.04)
+            labelNode.position = SCNVector3(pos.x, pos.y + 0.07, pos.z)
+            root.addChildNode(labelNode)
+            return root
+        }
+
+        /// Creates a billboard SCNText node that always faces the camera.
+        private func makeTextNode(text: String, color: UIColor, fontSize: CGFloat) -> SCNNode {
+            let scnText = SCNText(string: text, extrusionDepth: 0)
+            scnText.font = UIFont.systemFont(ofSize: fontSize * 100, weight: .medium)
+            scnText.firstMaterial?.diffuse.contents = color
+            scnText.firstMaterial?.lightingModel    = .constant
+            scnText.isWrapped = false
+
+            let textNode = SCNNode(geometry: scnText)
+            textNode.scale = SCNVector3(fontSize / 100, fontSize / 100, fontSize / 100)
+            // Billboard constraint — always face camera
+            let constraint = SCNBillboardConstraint()
+            constraint.freeAxes = .Y
+            textNode.constraints = [constraint]
+            // Centre text
+            let (min, max) = textNode.boundingBox
+            textNode.pivot = SCNMatrix4MakeTranslation((max.x - min.x) / 2, 0, 0)
+            return textNode
+        }
+
+        /// Builds a line strip SCNNode connecting all positions.
+        private func makeLineNode(through positions: [SCNVector3], color: UIColor) -> SCNNode {
+            guard positions.count >= 2 else { return SCNNode() }
+
+            var vertices: [SCNVector3] = positions
+            var indices: [Int32] = []
+            for i in 0..<(vertices.count - 1) {
+                indices.append(Int32(i))
+                indices.append(Int32(i + 1))
+            }
+
+            let vertexSource = SCNGeometrySource(vertices: vertices)
+            let element = SCNGeometryElement(
+                indices: indices,
+                primitiveType: .line
+            )
+            let geometry = SCNGeometry(sources: [vertexSource], elements: [element])
+            geometry.firstMaterial?.diffuse.contents = color
+            geometry.firstMaterial?.lightingModel    = .constant
+            return SCNNode(geometry: geometry)
+        }
+
+        private func hourLabel(from date: Date) -> String {
+            let fmt = DateFormatter()
+            fmt.dateFormat = "ha"
+            fmt.amSymbol   = "am"
+            fmt.pmSymbol   = "pm"
+            return fmt.string(from: date)
+        }
+
+        // MARK: - CoreMotion Fallback
+
+        private func activateCoreMotionFallback() {
+            // In fallback mode we rely on CMMotionManager attitude (already running in SunseekerViewModel)
+            // and just keep the scene nodes updated via the 1s tick in the VM.
+            print("[Sunseeker] Switched to CoreMotion fallback — ARKit tracking unavailable.")
+        }
     }
 }
 
+// MARK: - Degree helpers
+
 private extension Double {
     var radians: Double { self * .pi / 180.0 }
 }

iOS/velocity/velocity/Features/Inventory/InventoryView.swift

@@ -75,11 +75,8 @@ struct InventoryView: View {
                 switch store.mode {
                 case .sunseeker:
                     #if targetEnvironment(simulator)
-                    SimulatorUnavailableCard(
-                        icon: "camera.metering.unknown",
-                        title: "AR Not Available in Simulator",
-                        message: "Sunseeker requires a real device with a camera and compass. Run on iPhone or iPad to use this feature."
-                    )
+                    SimulatorSunOverlayView(sunNodesReady: $store.sunNodesReady)
+                        .clipShape(RoundedRectangle(cornerRadius: 20))
                     #else
                     SunseekerPanel(sunNodesReady: $store.sunNodesReady)
                     #endif
@@ -178,28 +175,70 @@ private struct SimulatorUnavailableCard: View {
 
 private struct SunseekerPanel: View {
     @Binding var sunNodesReady: Bool
+    @State private var vm = SunseekerViewModel()
 
     var body: some View {
         ZStack(alignment: .topLeading) {
-            ARSunOverlayView(sunNodesReady: $sunNodesReady)
+            ARSunOverlayView(sunNodesReady: $sunNodesReady, vm: vm)
                 .clipShape(RoundedRectangle(cornerRadius: 20))
 
+            // Retained as a stylistic design element framing the AR view
             DashedSunLine()
                 .stroke(Color.yellow.opacity(0.9), style: StrokeStyle(lineWidth: 3, dash: [10, 8]))
                 .padding(.horizontal, 24)
                 .padding(.vertical, 80)
 
-            VStack(alignment: .leading, spacing: 8) {
-                Text("Sunseeker")
-                    .font(.headline)
-                Text("Point the iPad toward windows to inspect yearly sun-entry path.")
-                    .font(.subheadline)
-                    .foregroundStyle(.secondary)
-            }
-            .padding(14)
-            .background {
-                GlassBlurView(style: .systemThinMaterial)
-                    .clipShape(RoundedRectangle(cornerRadius: 14))
+            VStack(alignment: .leading, spacing: 12) {
+                // Info block
+                VStack(alignment: .leading, spacing: 8) {
+                    Text("Sunseeker")
+                        .font(.headline)
+                    Text("Point the iPad toward windows to inspect yearly sun-entry path.")
+                        .font(.subheadline)
+                        .foregroundStyle(.secondary)
+                }
+                .padding(14)
+                .background {
+                    GlassBlurView(style: .systemThinMaterial)
+                        .clipShape(RoundedRectangle(cornerRadius: 14))
+                }
+
+                if !vm.isReady && vm.locationError == nil {
+                    // Loading state
+                    HStack(spacing: 8) {
+                        ProgressView().tint(.white)
+                        Text("Looking for the Sun...")
+                            .font(.footnote)
+                            .foregroundStyle(.white)
+                    }
+                    .padding(.horizontal, 14)
+                    .padding(.vertical, 10)
+                    .background(Color.black.opacity(0.6).clipShape(Capsule()))
+                }
+
+                // Error banner (e.g. Location Denied)
+                if let error = vm.locationError {
+                    HStack(spacing: 12) {
+                        Image(systemName: "exclamationmark.triangle.fill")
+                            .foregroundStyle(.yellow)
+                        Text(error)
+                            .font(.subheadline)
+                            .foregroundStyle(.white)
+                        Spacer()
+                        Button("Settings") {
+                            if let url = URL(string: UIApplication.openSettingsURLString) {
+                                UIApplication.shared.open(url)
+                            }
+                        }
+                        .buttonStyle(.borderedProminent)
+                        .tint(.white.opacity(0.2))
+                    }
+                    .padding(14)
+                    .background {
+                        RoundedRectangle(cornerRadius: 14)
+                            .fill(Color.red.opacity(0.8))
+                    }
+                }
             }
             .padding(20)
         }
@@ -208,19 +247,22 @@ private struct SunseekerPanel: View {
 
 // MARK: - Dream Weaver
 
-/// Available interior styles from integration guide §2.3
-private struct InteriorStyle: Identifiable {
-    let id: String          // sent as the `style` form field
+/// Available room types from integration guide §2
+private struct RoomType: Identifiable {
+    let id: String          // sent as the `room_type` form field
     let displayName: String
     let icon: String        // SF Symbol
 }
 
-private let dreamWeaverStyles: [InteriorStyle] = [
-    InteriorStyle(id: "scandinavian", displayName: "Scandi",   icon: "snowflake"),
-    InteriorStyle(id: "art_deco",     displayName: "Art Deco", icon: "sparkles"),
-    InteriorStyle(id: "biophilic",    displayName: "Biophilic",icon: "leaf"),
-    InteriorStyle(id: "cyberpunk",    displayName: "Cyberpunk",icon: "bolt"),
-    InteriorStyle(id: "japandi",      displayName: "Japandi",  icon: "mountain.2"),
+private let roomTypes: [RoomType] = [
+    RoomType(id: "bedroom",     displayName: "Bedroom",   icon: "bed.double"),
+    RoomType(id: "living_room", displayName: "Living Rm", icon: "sofa"),
+    RoomType(id: "bathroom",    displayName: "Bathroom",  icon: "drop"),
+    RoomType(id: "kitchen",     displayName: "Kitchen",   icon: "refrigerator"),
+    RoomType(id: "dining_room", displayName: "Dining Rm", icon: "fork.knife"),
+    RoomType(id: "home_office", displayName: "Office",    icon: "desktopcomputer"),
+    RoomType(id: "hallway",     displayName: "Hallway",   icon: "door.left.hand.open"),
+    RoomType(id: "balcony",     displayName: "Balcony",   icon: "sun.max"),
 ]
 
 private struct DreamWeaverPanel: View {
@@ -230,8 +272,8 @@ private struct DreamWeaverPanel: View {
     @Binding var errorMessage: String?
     @Binding var showCamera: Bool
 
-    /// Selected style ID — sent as `style` field (§3.2). nil = none chosen yet.
-    @State private var selectedStyle: String? = nil
+    /// Selected room type ID — sent as `room_type` field. nil = none chosen yet.
+    @State private var selectedRoomType: String? = nil
     /// Optional extra keywords — sent as `keywords` field (§3.2)
     @State private var keywords: String = ""
     /// Server health: nil = checking, true = online, false = offline
@@ -319,34 +361,34 @@ private struct DreamWeaverPanel: View {
                 .transition(.move(edge: .top).combined(with: .opacity))
             }
 
-            // ── Style picker (§2.3) ───────────────────────────────────────
+            // ── Room Type picker ───────────────────────────────────────
             ScrollView(.horizontal, showsIndicators: false) {
                 HStack(spacing: 8) {
-                    ForEach(dreamWeaverStyles) { style in
+                    ForEach(roomTypes) { room in
                         Button {
                             withAnimation(.spring(response: 0.3)) {
                                 // Tap again to deselect
-                                selectedStyle = selectedStyle == style.id ? nil : style.id
+                                selectedRoomType = selectedRoomType == room.id ? nil : room.id
                             }
                         } label: {
                             HStack(spacing: 6) {
-                                Image(systemName: style.icon)
+                                Image(systemName: room.icon)
                                     .font(.system(size: 11, weight: .medium))
-                                Text(style.displayName)
+                                Text(room.displayName)
                                     .font(.system(size: 13, weight: .medium))
                             }
                             .padding(.horizontal, 12)
                             .padding(.vertical, 7)
                             .background(
                                 Capsule()
-                                    .fill(selectedStyle == style.id
+                                    .fill(selectedRoomType == room.id
                                           ? Color(red: 0.231, green: 0.510, blue: 0.965)
                                           : Color.white.opacity(0.08))
                             )
-                            .foregroundStyle(selectedStyle == style.id ? .white : .white.opacity(0.6))
+                            .foregroundStyle(selectedRoomType == room.id ? .white : .white.opacity(0.6))
                             .overlay(
                                 Capsule()
-                                    .stroke(selectedStyle == style.id
+                                    .stroke(selectedRoomType == room.id
                                             ? Color.clear
                                             : Color.white.opacity(0.12), lineWidth: 1)
                             )
@@ -360,7 +402,7 @@ private struct DreamWeaverPanel: View {
             // ── Keywords input ───────────────────────────────────────────
             PromptInputBar(
                 text: $keywords,
-                isDisabled: sourceImage == nil || isProcessing
+                isDisabled: sourceImage == nil || isProcessing || serverOnline == false
             ) {
                 Task { await generate() }
             }
@@ -391,12 +433,16 @@ private struct DreamWeaverPanel: View {
     @MainActor
     private func generate() async {
         guard let sourceImage, !isProcessing else { return }
+        if serverOnline == false {
+            errorMessage = "Server is currently offline. Please try again later."
+            return
+        }
         isProcessing = true
         errorMessage = nil
         do {
             let result = try await ComfyClient.shared.generateImage(
                 source: sourceImage,
-                style: selectedStyle ?? dreamWeaverStyles[0].id,  // default: scandinavian
+                roomType: selectedRoomType ?? roomTypes[0].id,  // default: bedroom
                 keywords: keywords.trimmingCharacters(in: .whitespaces)
             )
             withAnimation(.easeInOut(duration: 0.4)) {
@@ -419,7 +465,7 @@ private struct PromptInputBar: View {
     @FocusState private var isFocused: Bool
     @State private var shimmer = false
 
-    private let placeholder = "gold, marble, luxury... (optional keywords)"
+    private let placeholder = "gold, marble, luxury, etc."
 
     var body: some View {
         HStack(spacing: 10) {

iOS/velocity/velocity/Features/Inventory/SimulatorSunOverlayView.swift

@@ -0,0 +1,256 @@
+import CoreLocation
+import SceneKit
+import SwiftUI
+
+#if targetEnvironment(simulator)
+
+/// A non-AR 3D view for testing the Sunseeker path logic on the iOS Simulator.
+/// Uses a synthetic camera, fake location, and mock heading instead of ARKit.
+struct SimulatorSunOverlayView: UIViewRepresentable {
+    @Binding var sunNodesReady: Bool
+    
+    // Fake location (e.g. San Francisco)
+    private let mockLocation = CLLocationCoordinate2D(latitude: 37.7749, longitude: -122.4194)
+    private let mockHeading: Double = 0 // North
+
+    func makeCoordinator() -> Coordinator {
+        Coordinator(sunNodesReady: $sunNodesReady, mockLocation: mockLocation, mockHeading: mockHeading)
+    }
+
+    func makeUIView(context: Context) -> SCNView {
+        let view = SCNView(frame: .zero)
+        view.scene = SCNScene()
+        view.allowsCameraControl = true // Swipe around the 3D space
+        view.autoenablesDefaultLighting = true
+        view.backgroundColor = UIColor(white: 0.1, alpha: 1.0)
+        view.isPlaying = true // Force render loop
+        view.showsStatistics = true // Prove it's rendering
+        
+        // Setup synthetic camera
+        let cameraNode = SCNNode()
+        cameraNode.camera = SCNCamera()
+        cameraNode.camera?.zFar = 100
+        cameraNode.position = SCNVector3(x: 0, y: 0, z: 0) // Centered
+        view.scene?.rootNode.addChildNode(cameraNode)
+        
+        context.coordinator.attach(to: view)
+        return view
+    }
+
+    func updateUIView(_ uiView: SCNView, context: Context) {}
+    
+    final class Coordinator: NSObject {
+        private weak var sceneView: SCNView?
+        @Binding private var sunNodesReady: Bool
+        
+        private let mockLocation: CLLocationCoordinate2D
+        private let mockHeading: Double
+        
+        private var arcRootNode      = SCNNode()
+        private var currentSunNode   = SCNNode()
+        
+        private var updateTimer: Timer?
+        
+        init(sunNodesReady: Binding<Bool>, mockLocation: CLLocationCoordinate2D, mockHeading: Double) {
+            _sunNodesReady = sunNodesReady
+            self.mockLocation = mockLocation
+            self.mockHeading = mockHeading
+            super.init()
+        }
+        
+        func attach(to view: SCNView) {
+            self.sceneView = view
+            view.scene?.rootNode.addChildNode(arcRootNode)
+            view.scene?.rootNode.addChildNode(currentSunNode)
+            buildScene()
+            startRealTimeTick()
+        }
+        
+        deinit {
+            updateTimer?.invalidate()
+        }
+        
+        private func startRealTimeTick() {
+            // Update current sun position every second
+            updateTimer = Timer.scheduledTimer(withTimeInterval: 1.0, repeats: true) { [weak self] _ in
+                guard let self = self else { return }
+                let cur = SunMath.calculateSunPosition(date: Date(), coordinate: self.mockLocation)
+                // Need to remove previous child as we are completely replacing it
+                self.currentSunNode.childNodes.forEach { $0.removeFromParentNode() }
+                
+                let radius: Float = 1.8
+                let orb = SCNSphere(radius: 0.055)
+                orb.firstMaterial?.diffuse.contents   = UIColor.systemOrange
+                orb.firstMaterial?.emission.contents  = UIColor.systemYellow
+                orb.firstMaterial?.lightingModel      = .constant
+                let orbNode = SCNNode(geometry: orb)
+                orbNode.position = self.worldPosition(for: cur, radius: radius)
+                
+                let pulse = CABasicAnimation(keyPath: "scale")
+                pulse.fromValue  = SCNVector3(1, 1, 1)
+                pulse.toValue    = SCNVector3(1.3, 1.3, 1.3)
+                pulse.duration   = 1.2
+                pulse.autoreverses = true
+                pulse.repeatCount  = .infinity
+                orbNode.addAnimation(pulse, forKey: "pulse")
+                
+                let label = self.makeTextNode(text: "Now", color: .systemYellow, fontSize: 0.05)
+                label.position = SCNVector3(0, 0.09, 0)
+                orbNode.addChildNode(label)
+                
+                self.currentSunNode.addChildNode(orbNode)
+            }
+        }
+        
+        private func buildScene() {
+            let arc = SunMath.sunPathArc(for: Date(), coordinate: mockLocation)
+            let riseSet = SunMath.sunRiseSet(for: Date(), coordinate: mockLocation)
+            let radius: Float = 1.8
+            var positions: [SCNVector3] = []
+            
+            // Hourly blocks
+            for (date, pos) in arc {
+                guard pos.elevation > -5 else { continue }
+                let worldPos = worldPosition(for: pos, radius: radius)
+                positions.append(worldPos)
+                
+                let sphere = SCNSphere(radius: 0.018)
+                sphere.firstMaterial?.diffuse.contents = UIColor.systemYellow.withAlphaComponent(0.85)
+                sphere.firstMaterial?.lightingModel = .constant
+                let markerNode = SCNNode(geometry: sphere)
+                markerNode.position = worldPos
+                arcRootNode.addChildNode(markerNode)
+                
+                let calendar = Calendar.current
+                let hour = calendar.component(.hour, from: date)
+                if hour % 2 == 0 {
+                    let labelNode = makeTextNode(text: hourLabel(from: date), color: .white, fontSize: 0.04)
+                    labelNode.position = SCNVector3(worldPos.x, worldPos.y + 0.06, worldPos.z)
+                    arcRootNode.addChildNode(labelNode)
+                }
+            }
+            
+            if positions.count >= 2 {
+                let lineNode = makeLineNode(through: positions, color: UIColor.systemYellow.withAlphaComponent(0.55))
+                arcRootNode.addChildNode(lineNode)
+            }
+            
+            if let riseDate = riseSet.rise {
+                let risePos = SunMath.calculateSunPosition(date: riseDate, coordinate: mockLocation)
+                let wPos = worldPosition(for: risePos, radius: radius)
+                arcRootNode.addChildNode(makeSpecialMarker(at: wPos, color: .systemOrange, label: "Sunrise \(hourLabel(from: riseDate))"))
+            }
+            
+            if let setDate = riseSet.set {
+                let setPos = SunMath.calculateSunPosition(date: setDate, coordinate: mockLocation)
+                let wPos = worldPosition(for: setPos, radius: radius)
+                arcRootNode.addChildNode(makeSpecialMarker(at: wPos, color: .systemRed, label: "Sunset \(hourLabel(from: setDate))"))
+            }
+            
+            // Generate current sun node synchronously for first frame
+            updateTimer?.fire()
+            
+            DispatchQueue.main.async {
+                self.sunNodesReady = true
+            }
+        }
+        
+        // MARK: Math equivalent from SunseekerViewModel
+        
+        private func worldPosition(for sun: SunPosition, radius: Float) -> SCNVector3 {
+            let elev = Float(sun.elevation * .pi / 180.0)
+            let az   = Float(sun.azimuth * .pi / 180.0)
+            let x    =  radius * cos(elev) * sin(az)
+            let y    =  radius * sin(elev)
+            let z    = -radius * cos(elev) * cos(az)
+            return SCNVector3(x, y, z)
+        }
+        
+        // MARK: SceneKit Factories
+        
+        private func makeSpecialMarker(at pos: SCNVector3, color: UIColor, label: String) -> SCNNode {
+            let root   = SCNNode()
+            let sphere = SCNSphere(radius: 0.035)
+            sphere.firstMaterial?.diffuse.contents  = color
+            sphere.firstMaterial?.emission.contents = color.withAlphaComponent(0.5)
+            sphere.firstMaterial?.lightingModel     = .constant
+            let markerNode = SCNNode(geometry: sphere)
+            markerNode.position = pos
+            root.addChildNode(markerNode)
+
+            let labelNode = makeTextNode(text: label, color: .white, fontSize: 0.04)
+            labelNode.position = SCNVector3(pos.x, pos.y + 0.07, pos.z)
+            root.addChildNode(labelNode)
+            return root
+        }
+
+        private func makeTextNode(text: String, color: UIColor, fontSize: CGFloat) -> SCNNode {
+            // SCNText is buggy in Simulator. Render text to a UIImage instead.
+            let font = UIFont.systemFont(ofSize: 40, weight: .bold)
+            let attributes: [NSAttributedString.Key: Any] = [
+                .font: font,
+                .foregroundColor: color
+            ]
+            let size = (text as NSString).size(withAttributes: attributes)
+            
+            // Add some padding
+            let paddedSize = CGSize(width: size.width + 10, height: size.height + 10)
+            
+            let renderer = UIGraphicsImageRenderer(size: paddedSize)
+            let image = renderer.image { context in
+                (text as NSString).draw(
+                    in: CGRect(x: 5, y: 5, width: size.width, height: size.height),
+                    withAttributes: attributes
+                )
+            }
+            
+            // Map the image onto an SCNPlane
+            // A 100x50 image becomes a 0.1 x 0.05 meter plane
+            let plane = SCNPlane(width: paddedSize.width / 1000.0, height: paddedSize.height / 1000.0)
+            plane.firstMaterial?.diffuse.contents = image
+            plane.firstMaterial?.isDoubleSided = true
+            plane.firstMaterial?.lightingModel = .constant
+            
+            let textNode = SCNNode(geometry: plane)
+            // Statically scale the plane up so it is readable next to the spheres
+            textNode.scale = SCNVector3(1.5, 1.5, 1.5)
+            
+            let constraint = SCNBillboardConstraint()
+            constraint.freeAxes = .all
+            textNode.constraints = [constraint]
+            
+            return textNode
+        }
+
+        private func makeLineNode(through positions: [SCNVector3], color: UIColor) -> SCNNode {
+            guard positions.count >= 2 else { return SCNNode() }
+
+            var vertices: [SCNVector3] = positions
+            var indices: [Int32] = []
+            for i in 0..<(vertices.count - 1) {
+                indices.append(Int32(i))
+                indices.append(Int32(i + 1))
+            }
+
+            let vertexSource = SCNGeometrySource(vertices: vertices)
+            let element = SCNGeometryElement(
+                indices: indices,
+                primitiveType: .line
+            )
+            let geometry = SCNGeometry(sources: [vertexSource], elements: [element])
+            geometry.firstMaterial?.diffuse.contents = color
+            geometry.firstMaterial?.lightingModel    = .constant
+            return SCNNode(geometry: geometry)
+        }
+
+        private func hourLabel(from date: Date) -> String {
+            let fmt = DateFormatter()
+            fmt.dateFormat = "ha"
+            fmt.amSymbol   = "am"
+            fmt.pmSymbol   = "pm"
+            return fmt.string(from: date)
+        }
+    }
+}
+
+#endif

iOS/velocity/velocity/Features/Inventory/SunseekerViewModel.swift

@@ -0,0 +1,140 @@
+import CoreLocation
+import CoreMotion
+import Foundation
+import Observation
+import SceneKit
+
+// MARK: - SunseekerViewModel
+
+/// Owns all sensor state for the Sunseeker AR overlay.
+/// Separates CoreLocation / CoreMotion concerns from the ARKit view layer.
+@Observable
+final class SunseekerViewModel: NSObject, CLLocationManagerDelegate {
+
+    // MARK: - Published State
+
+    /// True once we have both a GPS fix and a valid heading.
+    private(set) var isReady  = false
+
+    /// Latest GPS coordinate. nil until first fix.
+    private(set) var coordinate: CLLocationCoordinate2D?
+
+    /// Latest true heading (0 = North, clockwise).
+    private(set) var heading: Double = 0
+
+    /// Dense hourly arc for today.
+    private(set) var arc: [(date: Date, position: SunPosition)] = []
+
+    /// Current real-time sun position (updated every second).
+    private(set) var currentPosition: SunPosition?
+
+    /// Sunrise and sunset for today.
+    private(set) var riseSet: (rise: Date?, set: Date?) = (nil, nil)
+
+    /// Diagnostic string for the UI when location access is denied.
+    private(set) var locationError: String?
+
+    // MARK: - Private
+
+    private let locationManager = CLLocationManager()
+    private let motionManager   = CMMotionManager()
+    private var updateTimer: Timer?
+
+    // MARK: - Init / Deinit
+
+    override init() {
+        super.init()
+        locationManager.delegate          = self
+        locationManager.desiredAccuracy   = kCLLocationAccuracyBest
+        locationManager.headingFilter     = 1.0
+        locationManager.requestWhenInUseAuthorization()
+        locationManager.startUpdatingLocation()
+        locationManager.startUpdatingHeading()
+        startMotionUpdates()
+        startRealTimeTick()
+    }
+
+    deinit {
+        stop()
+    }
+
+    // MARK: - Control
+
+    func stop() {
+        motionManager.stopDeviceMotionUpdates()
+        locationManager.stopUpdatingLocation()
+        locationManager.stopUpdatingHeading()
+        updateTimer?.invalidate()
+        updateTimer = nil
+    }
+
+    // MARK: - World-Space Transform
+
+    /// Converts a solar `SunPosition` into a SceneKit world-space position on a sphere of given `radius`.
+    /// Orientation is relative to ARWorldTrackingConfiguration(.gravityAndHeading), so north = -Z axis.
+    func worldPosition(for sun: SunPosition, radius: Float) -> SCNVector3 {
+        let elev = Float(sun.elevation.radians)
+        let az   = Float(sun.azimuth.radians)          // clockwise from north
+        let x    =  radius * cos(elev) * sin(az)
+        let y    =  radius * sin(elev)
+        let z    = -radius * cos(elev) * cos(az)       // -Z = north in ARKit gravity+heading
+        return SCNVector3(x, y, z)
+    }
+
+    // MARK: - Private helpers
+
+    private func startMotionUpdates() {
+        guard motionManager.isDeviceMotionAvailable else { return }
+        motionManager.deviceMotionUpdateInterval = 0.05
+        motionManager.startDeviceMotionUpdates()
+    }
+
+    private func startRealTimeTick() {
+        updateTimer = Timer.scheduledTimer(withTimeInterval: 1.0, repeats: true) { [weak self] _ in
+            guard let self, let coord = self.coordinate else { return }
+            self.currentPosition = SunMath.calculateSunPosition(date: Date(), coordinate: coord)
+        }
+    }
+
+    private func refreshArc() {
+        guard let coord = coordinate else { return }
+        arc          = SunMath.sunPathArc(for: Date(), coordinate: coord)
+        riseSet      = SunMath.sunRiseSet(for: Date(), coordinate: coord)
+        currentPosition = SunMath.calculateSunPosition(date: Date(), coordinate: coord)
+        isReady      = true
+    }
+
+    // MARK: - CLLocationManagerDelegate
+
+    func locationManager(_ manager: CLLocationManager, didUpdateLocations locations: [CLLocation]) {
+        guard coordinate == nil, let loc = locations.last else { return }
+        coordinate = loc.coordinate
+        refreshArc()
+    }
+
+    func locationManager(_ manager: CLLocationManager, didUpdateHeading newHeading: CLHeading) {
+        heading = newHeading.trueHeading > 0 ? newHeading.trueHeading : newHeading.magneticHeading
+        if coordinate != nil { isReady = true }
+    }
+
+    func locationManager(_ manager: CLLocationManager, didFailWithError error: Error) {
+        print("[Sunseeker] Location error: \(error.localizedDescription)")
+    }
+
+    func locationManagerDidChangeAuthorization(_ manager: CLLocationManager) {
+        switch manager.authorizationStatus {
+        case .denied, .restricted:
+            locationError = "Location access needed to calculate the sun path. Please enable it in Settings."
+        case .notDetermined:
+            manager.requestWhenInUseAuthorization()
+        default:
+            locationError = nil
+        }
+    }
+}
+
+// MARK: - Degree helpers (internal to this file)
+
+private extension Double {
+    var radians: Double { self * .pi / 180.0 }
+}

iOS/velocity/velocity/Info.plist

@@ -13,5 +13,8 @@
 	<string>Velocity would like to save your AI-generated room design to your photo library.</string>
 	<key>NSCameraUsageDescription</key>
 	<string>Velocity needs camera access to capture room photos for Dream Weaver.</string>
+	<key>NSLocationWhenInUseUsageDescription</key>
+	<string>Velocity uses your location to calculate the accurate sun path for your property.</string>
 </dict>
 </plist>
+