@@ -7,39 +7,45 @@ class DownloadSignManager: ObservableObject {
     @Published var status: String = ""
     @Published var isProcessing: Bool = false
     @Published var showSuccess: Bool = false
-    
+
     private var downloadTask: URLSessionDownloadTask?
+    private var downloadProgressObservation: NSKeyValueObservation?
     private var installationStream: AsyncThrowingStream<(progress: Double, status: String), Error>?
     private var installationTask: Task<Void, Never>?
     private var cancellables = Set<AnyCancellable>()
-    
+
+    // Portion split (tweak if you want different ratios)
+    private let downloadPortion: Double = 0.33
+    private let signPortion: Double = 0.33
+    private let installPortion: Double = 1.0 - (0.33 + 0.33) // ~0.34
+
     func downloadAndSign(app: AltApp) {
         guard let downloadURL = app.downloadURL else {
             self.status = "No download URL available"
             return
         }
-        
+
         guard let selectedCertFolder = UserDefaults.standard.string(forKey: "selectedCertificateFolder") else {
             self.status = "No certificate selected"
             return
         }
-        
+
         self.isProcessing = true
         self.progress = 0.0
         self.status = "Starting download..."
         self.showSuccess = false
-        
+
         DispatchQueue.global(qos: .userInitiated).async {
             self.performDownloadAndSign(downloadURL: downloadURL, appName: app.name, certFolder: selectedCertFolder)
         }
     }
-    
+
     private func performDownloadAndSign(downloadURL: URL, appName: String, certFolder: String) {
         // Step 1: Setup directories
         let fm = FileManager.default
         let appFolder = self.getAppFolder()
         let tempDir = appFolder.appendingPathComponent("temp")
-        
+
         do {
             if !fm.fileExists(atPath: tempDir.path) {
                 try fm.createDirectory(at: tempDir, withIntermediateDirectories: true)
@@ -51,13 +57,16 @@ class DownloadSignManager: ObservableObject {
             }
             return
         }
-        
+
         let tempIPAURL = tempDir.appendingPathComponent("\(UUID().uuidString).ipa")
-        
-        // Step 2: Download the IPA
+
+        // Step 2: Download the IPA (with progress)
         self.downloadIPA(from: downloadURL, to: tempIPAURL) { [weak self] result in
             guard let self = self else { return }
-            
+
+            // ensure observer cleared
+            self.downloadProgressObservation = nil
+
             switch result {
             case .success:
                 // Step 3: Get certificate files
@@ -68,80 +77,158 @@ class DownloadSignManager: ObservableObject {
                     }
                     return
                 }
-                
+
                 // Step 4: Sign the IPA
                 self.signIPA(ipaURL: tempIPAURL, p12URL: p12URL, provURL: provURL, password: password, appName: appName)
-                
+
             case .failure(let error):
                 DispatchQueue.main.async {
                     self.status = "Download failed: \(error.localizedDescription)"
                     self.isProcessing = false
                 }
-                
+
                 // Clean up temp file if it exists
                 try? FileManager.default.removeItem(at: tempIPAURL)
             }
         }
     }
-    
+
+    // Download with progress observer and final move to destination
+    private func downloadIPA(from url: URL, to destinationURL: URL, completion: @escaping (Result<Void, Error>) -> Void) {
+        let request = URLRequest(url: url)
+        let session = URLSession(configuration: .default)
+
+        DispatchQueue.main.async {
+            self.status = "Downloading... (0%)"
+            self.progress = 0.0
+        }
+
+        let task = session.downloadTask(with: request) { [weak self] tempLocalURL, response, error in
+            guard let self = self else { return }
+
+            if let error = error as NSError?, error.domain == NSURLErrorDomain, error.code == NSURLErrorCancelled {
+                DispatchQueue.main.async {
+                    self.status = "Cancelled"
+                    self.isProcessing = false
+                    self.progress = 0.0
+                }
+                completion(.failure(error))
+                return
+            }
+
+            if let error = error {
+                completion(.failure(error))
+                return
+            }
+
+            guard let tempLocalURL = tempLocalURL else {
+                let err = NSError(domain: "DownloadSignManager", code: -1, userInfo: [NSLocalizedDescriptionKey: "No temp file URL"])
+                completion(.failure(err))
+                return
+            }
+
+            do {
+                // If destination exists, remove it
+                if FileManager.default.fileExists(atPath: destinationURL.path) {
+                    try FileManager.default.removeItem(at: destinationURL)
+                }
+                try FileManager.default.moveItem(at: tempLocalURL, to: destinationURL)
+
+                DispatchQueue.main.async {
+                    // make sure progress reflects completed download within its portion
+                    self.progress = self.downloadPortion
+                    self.status = "Downloaded (100%)"
+                }
+
+                completion(.success(()))
+            } catch {
+                completion(.failure(error))
+            }
+        }
+
+        // keep reference for cancel()
+        self.downloadTask = task
+
+        // Observe the Progress
+        self.downloadProgressObservation = task.progress.observe(\.fractionCompleted, options: [.initial, .new]) { [weak self] progressObj, _ in
+            guard let self = self else { return }
+            DispatchQueue.main.async {
+                let fraction = progressObj.fractionCompleted // 0.0 .. 1.0
+                // Map download fraction to [0 .. downloadPortion]
+                let overall = fraction * self.downloadPortion
+                self.progress = overall
+
+                let percent = Int(round(fraction * 100))
+                self.status = "Downloading... (\(percent)%)"
+            }
+        }
+
+        task.resume()
+    }
+
     private func signIPA(ipaURL: URL, p12URL: URL, provURL: URL, password: String, appName: String) {
         DispatchQueue.main.async {
             self.status = "Starting signing process..."
-            self.progress = 0.5
+            // keep progress where download left off (downloadPortion)
         }
-        
+
         signer.sign(
             ipaURL: ipaURL,
             p12URL: p12URL,
             provURL: provURL,
             p12Password: password,
             progressUpdate: { [weak self] status, progress in
                 DispatchQueue.main.async {
-                    // Signing takes first 50% of progress
-                    let overallProgress = 0.0 + (progress * 0.5)
-                    self?.progress = overallProgress
-                    let percent = Int(overallProgress * 100)
-                    self?.status = "\(status) (\(percent)%)"
+                    guard let self = self else { return }
+                    // Signing maps to the middle portion (downloadPortion .. downloadPortion + signPortion)
+                    let overallProgress = self.downloadPortion + (progress * self.signPortion)
+                    self.progress = overallProgress
+                    let percentOfSign = Int(round(progress * 100))
+                    let overallPercent = Int(round(overallProgress * 100))
+                    self.status = "\(status) (\(overallPercent)%)"
+                    // If you want a "Signing... (xx%)" label specifically, you can use:
+                    // self.status = "Signing... (\(percentOfSign)%)"
                 }
             },
             completion: { [weak self] result in
                 DispatchQueue.main.async {
+                    guard let self = self else { return }
                     switch result {
                     case .success(let signedIPAURL):
-                        self?.progress = 0.5
-                        self?.status = "✅ Signed! Installing app..."
-                        
+                        // After signing, set progress to end of signing portion
+                        self.progress = self.downloadPortion + self.signPortion
+                        self.status = "✅ Signed! Installing app..."
                         // Start installation and track progress
-                        self?.startInstallation(signedIPAURL: signedIPAURL)
-                        
+                        self.startInstallation(signedIPAURL: signedIPAURL)
+
                         // Clean up original downloaded IPA
                         try? FileManager.default.removeItem(at: ipaURL)
-                        
+
                     case .failure(let error):
-                        self?.status = "❌ Signing failed: \(error.localizedDescription)"
-                        self?.isProcessing = false
+                        self.status = "❌ Signing failed: \(error.localizedDescription)"
+                        self.isProcessing = false
                         try? FileManager.default.removeItem(at: ipaURL)
                     }
                 }
             }
         )
     }
-    
+
     private func startInstallation(signedIPAURL: URL) {
         self.installationTask = Task {
             do {
                 // Get the installation progress stream
                 let stream = try await installApp(from: signedIPAURL)
                 self.installationStream = stream
-                
+
                 // Process installation progress updates
                 for try await (installProgress, installStatus) in stream {
                     await MainActor.run {
-                        // Installation takes second 50% of progress (0.5 to 1.0)
-                        let overallProgress = 0.5 + (installProgress * 0.5)
+                        // Installation maps to final portion:
+                        let overallProgress = self.downloadPortion + self.signPortion + (installProgress * self.installPortion)
                         self.progress = overallProgress
-                        
-                        let percent = Int(overallProgress * 100)
+
+                        let percent = Int(round(overallProgress * 100))
                         if installStatus.contains("Successfully") {
                             self.status = installStatus
                             self.showSuccess = true
@@ -150,12 +237,13 @@ class DownloadSignManager: ObservableObject {
                         }
                     }
                 }
-                
+
                 // Installation completed successfully
                 await MainActor.run {
+                    self.progress = 1.0
                     self.status = "✅ Successfully installed app!"
                     self.showSuccess = true
-                    
+
                     // Hide progress bar after 5 seconds
                     DispatchQueue.main.asyncAfter(deadline: .now() + 5) {
                         self.isProcessing = false
@@ -166,7 +254,7 @@ class DownloadSignManager: ObservableObject {
                         self.installationTask = nil
                     }
                 }
-                
+
             } catch {
                 await MainActor.run {
                     self.status = "❌ Install failed: \(error.localizedDescription)"
@@ -177,20 +265,23 @@ class DownloadSignManager: ObservableObject {
             }
         }
     }
-    
+
     func cancel() {
         downloadTask?.cancel()
         installationTask?.cancel()
         installationStream = nil
         installationTask = nil
-        
+
+        // Remove observer
+        downloadProgressObservation = nil
+
         DispatchQueue.main.async {
             self.isProcessing = false
             self.status = "Cancelled"
             self.progress = 0.0
         }
     }
-    
+
     private func getAppFolder() -> URL {
         let fm = FileManager.default
         let documents = fm.urls(for: .documentDirectory, in: .userDomainMask).first!
@@ -200,5 +291,3 @@ class DownloadSignManager: ObservableObject {
         }
         return appFolder
     }
-
-}