Fastest and only macOS Dictation app with on-device STT and custom trained AI enhancement model. Windows, iOS testflight! Android, Linux waitlist open! A local Wispr Flow alternative. Follow https://x.com/fluidvoiceapp for more
Prepare beta 8: Fluid Speech models and reliability fixes (#1063)
ALTIC18bb4c635fd6
diff --git a/.github/workflows/build.yml b/.github/workflows/build.ymlindex cb60fb62..07c9ba7b 100644--- a/.github/workflows/build.yml+++ b/.github/workflows/build.yml@@ -94,6 +94,12 @@ jobs:- name: Run release highlights regressionsrun: sh Tests/run_release_highlights_tests.sh+ - name: Run settings backup concurrency regressions+ run: python3 Tests/run_settings_backup_concurrency_tests.py++ - name: Run meeting backup refresh regressions+ run: python3 Tests/run_meeting_backup_refresh_tests.py+# Tiny Whisper GGUF output is nondeterministic on hosted macOS runners.# Keep this E2E assertion in the suite for local validation, but skip it in CI.- name: Build and test (excluding flaky Tiny Whisper E2E)diff --git a/Fluid.xcodeproj/project.pbxproj b/Fluid.xcodeproj/project.pbxprojindex cff8e548..c13ecd61 100644--- a/Fluid.xcodeproj/project.pbxproj+++ b/Fluid.xcodeproj/project.pbxproj@@ -7,6 +7,18 @@objects = {/* Begin PBXBuildFile section */+ D63B0F8456B440F1A123B987 /* PronunciationModelRevisionTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = AFA73C8D5E7647C4AB125DEE /* PronunciationModelRevisionTests.swift */; };+ 5D4A9F54826FD6BB32CE13F8 /* SpeechModelInstallationSnapshotTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = 7D47EF42AC1B641A705AC302 /* SpeechModelInstallationSnapshotTests.swift */; };+ B51B7EE5BA8CE09BC09A47DB /* ProgressiveFileDownloaderTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = 70362FCD2F941BFB800AD8E8 /* ProgressiveFileDownloaderTests.swift */; };+ 9F12D6C37B0166B549AECB61 /* ParakeetCompactModelDemoTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = 16DE344948E4DBF0E1739769 /* ParakeetCompactModelDemoTests.swift */; };+ 209C92C604F912C74A733D21 /* ParakeetCompactModelSmokeTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = BC9A7E0C9B501E87114F7A88 /* ParakeetCompactModelSmokeTests.swift */; };+ 67F6BBBA604C996A20BEE7AC /* ParakeetArchiveDownloaderTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = E3398800F76A93226E76A5C9 /* ParakeetArchiveDownloaderTests.swift */; };+ EA91B858DDC9E68655DCA343 /* ParakeetSpeechModelCatalogTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = 6BF00D40A027DC3970C2D0AE /* ParakeetSpeechModelCatalogTests.swift */; };+ 24AFD1DFC6BFC9DB5BC6329B /* UpdateRollbackBackupTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = 91C92FF93D3D21E0FD4D93EE /* UpdateRollbackBackupTests.swift */; };+ 563881F82B15C86EDB50E198 /* UpdateInstallationPipelineTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = F12B5FA911AD928DAFD058FB /* UpdateInstallationPipelineTests.swift */; };+ 7EAA9E7C4E4155A44F9CC415 /* UpdateAppReplacementTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = 8E4FCA0BC854678A142D944F /* UpdateAppReplacementTests.swift */; };+ 6AE26D3BB678D13615C41376 /* UpdateBundleValidatorTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = 93E63CD61E6BD954698A8E63 /* UpdateBundleValidatorTests.swift */; };+ 75454216C2DD7BBBB1D76D42 /* SettingsBackupRoundTripTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = 4263717D7203AAA6B63D9330 /* SettingsBackupRoundTripTests.swift */; };FEA4AB111222333444555504 /* MeetingModelResidencyTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = FEA4AB111222333444555503 /* MeetingModelResidencyTests.swift */; };AB492EFF712C42EE91601004 /* MeetingSummaryDownloadTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = AB492EFF712C42EE91601003 /* MeetingSummaryDownloadTests.swift */; };AB492EFF712C42EE91601002 /* MeetingSummaryInputTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = AB492EFF712C42EE91601001 /* MeetingSummaryInputTests.swift */; };@@ -114,6 +126,8 @@A5B000000000000000000018 /* MediaRemoteAdapter in Embed Frameworks */ = {isa = PBXBuildFile; productRef = 7C5AF14A2F15041600DE21B0 /* MediaRemoteAdapter */; settings = {ATTRIBUTES = (CodeSignOnCopy, RemoveHeadersOnCopy, ); }; };A5B000000000000000000023 /* XCTest.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 7CDB0A2C2F3C4D5600FB7CAD /* XCTest.framework */; };D1C7A7100000000000000002 /* UpdatePromptIntegrationTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = D1C7A7100000000000000001 /* UpdatePromptIntegrationTests.swift */; };+ C093F64545C6FDD2D79BF559 /* ParakeetArchiveInstallerTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = 5F06B51CF3F45AF989D0CA7F /* ParakeetArchiveInstallerTests.swift */; };+ 640AB09C7781553DF72D1156 /* CompactSpeechModelArchiveTransportTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = 01DEEE85A263FAED9ED5DEF8 /* CompactSpeechModelArchiveTransportTests.swift */; };/* End PBXBuildFile section *//* Begin PBXContainerItemProxy section */@@ -159,6 +173,18 @@/* End PBXCopyFilesBuildPhase section *//* Begin PBXFileReference section */+ AFA73C8D5E7647C4AB125DEE /* PronunciationModelRevisionTests.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = PronunciationModelRevisionTests.swift; sourceTree = "<group>"; };+ 7D47EF42AC1B641A705AC302 /* SpeechModelInstallationSnapshotTests.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = SpeechModelInstallationSnapshotTests.swift; sourceTree = "<group>"; };+ 70362FCD2F941BFB800AD8E8 /* ProgressiveFileDownloaderTests.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = ProgressiveFileDownloaderTests.swift; sourceTree = "<group>"; };+ 16DE344948E4DBF0E1739769 /* ParakeetCompactModelDemoTests.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = ParakeetCompactModelDemoTests.swift; sourceTree = "<group>"; };+ BC9A7E0C9B501E87114F7A88 /* ParakeetCompactModelSmokeTests.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = ParakeetCompactModelSmokeTests.swift; sourceTree = "<group>"; };+ E3398800F76A93226E76A5C9 /* ParakeetArchiveDownloaderTests.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = ParakeetArchiveDownloaderTests.swift; sourceTree = "<group>"; };+ 6BF00D40A027DC3970C2D0AE /* ParakeetSpeechModelCatalogTests.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = ParakeetSpeechModelCatalogTests.swift; sourceTree = "<group>"; };+ 91C92FF93D3D21E0FD4D93EE /* UpdateRollbackBackupTests.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = UpdateRollbackBackupTests.swift; sourceTree = "<group>"; };+ F12B5FA911AD928DAFD058FB /* UpdateInstallationPipelineTests.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = UpdateInstallationPipelineTests.swift; sourceTree = "<group>"; };+ 8E4FCA0BC854678A142D944F /* UpdateAppReplacementTests.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = UpdateAppReplacementTests.swift; sourceTree = "<group>"; };+ 93E63CD61E6BD954698A8E63 /* UpdateBundleValidatorTests.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = UpdateBundleValidatorTests.swift; sourceTree = "<group>"; };+ 4263717D7203AAA6B63D9330 /* SettingsBackupRoundTripTests.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = SettingsBackupRoundTripTests.swift; sourceTree = "<group>"; };FEA4AB111222333444555503 /* MeetingModelResidencyTests.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = MeetingModelResidencyTests.swift; sourceTree = "<group>"; };AB492EFF712C42EE91601003 /* MeetingSummaryDownloadTests.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = MeetingSummaryDownloadTests.swift; sourceTree = "<group>"; };AB492EFF712C42EE91601001 /* MeetingSummaryInputTests.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = MeetingSummaryInputTests.swift; sourceTree = "<group>"; };@@ -255,6 +281,8 @@A5B00000000000000000000F /* placeholder.json */ = {isa = PBXFileReference; lastKnownFileType = text.json; path = placeholder.json; sourceTree = "<group>"; };A5B00000000000000000001D /* FluidASRBaselineTests.xctest */ = {isa = PBXFileReference; explicitFileType = wrapper.cfbundle; includeInIndex = 0; path = FluidASRBaselineTests.xctest; sourceTree = BUILT_PRODUCTS_DIR; };D1C7A7100000000000000001 /* UpdatePromptIntegrationTests.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = UpdatePromptIntegrationTests.swift; sourceTree = "<group>"; };+ 5F06B51CF3F45AF989D0CA7F /* ParakeetArchiveInstallerTests.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = ParakeetArchiveInstallerTests.swift; sourceTree = "<group>"; };+ 01DEEE85A263FAED9ED5DEF8 /* CompactSpeechModelArchiveTransportTests.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = CompactSpeechModelArchiveTransportTests.swift; sourceTree = "<group>"; };/* End PBXFileReference section *//* Begin PBXFileSystemSynchronizedBuildFileExceptionSet section */@@ -367,6 +395,20 @@7CDB0A262F3C4D5600FB7CAD /* Helpers */,7CDB0A272F3C4D5600FB7CAD /* Resources */,D1C7A7100000000000000001 /* UpdatePromptIntegrationTests.swift */,+ 4263717D7203AAA6B63D9330 /* SettingsBackupRoundTripTests.swift */,+ 91C92FF93D3D21E0FD4D93EE /* UpdateRollbackBackupTests.swift */,+ F12B5FA911AD928DAFD058FB /* UpdateInstallationPipelineTests.swift */,+ 8E4FCA0BC854678A142D944F /* UpdateAppReplacementTests.swift */,+ 93E63CD61E6BD954698A8E63 /* UpdateBundleValidatorTests.swift */,+ 7D47EF42AC1B641A705AC302 /* SpeechModelInstallationSnapshotTests.swift */,+ 70362FCD2F941BFB800AD8E8 /* ProgressiveFileDownloaderTests.swift */,+ AFA73C8D5E7647C4AB125DEE /* PronunciationModelRevisionTests.swift */,+ 16DE344948E4DBF0E1739769 /* ParakeetCompactModelDemoTests.swift */,+ BC9A7E0C9B501E87114F7A88 /* ParakeetCompactModelSmokeTests.swift */,+ E3398800F76A93226E76A5C9 /* ParakeetArchiveDownloaderTests.swift */,+ 01DEEE85A263FAED9ED5DEF8 /* CompactSpeechModelArchiveTransportTests.swift */,+ 5F06B51CF3F45AF989D0CA7F /* ParakeetArchiveInstallerTests.swift */,+ 6BF00D40A027DC3970C2D0AE /* ParakeetSpeechModelCatalogTests.swift */,7CDB0A292F3C4D5600FB7CAD /* DictationE2ETests.swift */,CD1C7A0000000000000000B1 /* CustomDictionaryManualEntryTests.swift */,7C91B0022F42AA0100C0DEF0 /* HotkeyShortcutTests.swift */,@@ -723,6 +765,20 @@files = (7CDB0A2E2F3C4D5600FB7CAD /* AudioFixtureLoader.swift in Sources */,D1C7A7100000000000000002 /* UpdatePromptIntegrationTests.swift in Sources */,+ 75454216C2DD7BBBB1D76D42 /* SettingsBackupRoundTripTests.swift in Sources */,+ 24AFD1DFC6BFC9DB5BC6329B /* UpdateRollbackBackupTests.swift in Sources */,+ 563881F82B15C86EDB50E198 /* UpdateInstallationPipelineTests.swift in Sources */,+ 7EAA9E7C4E4155A44F9CC415 /* UpdateAppReplacementTests.swift in Sources */,+ 6AE26D3BB678D13615C41376 /* UpdateBundleValidatorTests.swift in Sources */,+ 5D4A9F54826FD6BB32CE13F8 /* SpeechModelInstallationSnapshotTests.swift in Sources */,+ B51B7EE5BA8CE09BC09A47DB /* ProgressiveFileDownloaderTests.swift in Sources */,+ D63B0F8456B440F1A123B987 /* PronunciationModelRevisionTests.swift in Sources */,+ 9F12D6C37B0166B549AECB61 /* ParakeetCompactModelDemoTests.swift in Sources */,+ 209C92C604F912C74A733D21 /* ParakeetCompactModelSmokeTests.swift in Sources */,+ 67F6BBBA604C996A20BEE7AC /* ParakeetArchiveDownloaderTests.swift in Sources */,+ 640AB09C7781553DF72D1156 /* CompactSpeechModelArchiveTransportTests.swift in Sources */,+ C093F64545C6FDD2D79BF559 /* ParakeetArchiveInstallerTests.swift in Sources */,+ EA91B858DDC9E68655DCA343 /* ParakeetSpeechModelCatalogTests.swift in Sources */,7CDB0A2D2F3C4D5600FB7CAD /* DictationE2ETests.swift in Sources */,B52000000000000000000002 /* PrivateAIDictationTokenBudgetTests.swift in Sources */,CD1C7A0000000000000000B2 /* CustomDictionaryManualEntryTests.swift in Sources */,@@ -1320,7 +1376,7 @@repositoryURL = "https://github.com/altic-dev/FluidAudio.git";requirement = {kind = revision;- revision = 09c23cce76126920b3ff6710cdb154bdf9c126b8;+ revision = eb1e6628998e47022799d305b52c2680d3576801;};};diff --git a/Fluid.xcodeproj/project.xcworkspace/xcshareddata/swiftpm/Package.resolved b/Fluid.xcodeproj/project.xcworkspace/xcshareddata/swiftpm/Package.resolvedindex 9121c9bb..ea0494b1 100644--- a/Fluid.xcodeproj/project.xcworkspace/xcshareddata/swiftpm/Package.resolved+++ b/Fluid.xcodeproj/project.xcworkspace/xcshareddata/swiftpm/Package.resolved@@ -32,7 +32,7 @@"kind" : "remoteSourceControl","location" : "https://github.com/altic-dev/FluidAudio.git","state" : {- "revision" : "09c23cce76126920b3ff6710cdb154bdf9c126b8"+ "revision" : "eb1e6628998e47022799d305b52c2680d3576801"}},{diff --git a/Package.resolved b/Package.resolvedindex ba9dc633..0894533a 100644--- a/Package.resolved+++ b/Package.resolved@@ -31,7 +31,7 @@"kind" : "remoteSourceControl","location" : "https://github.com/altic-dev/FluidAudio.git","state" : {- "revision" : "09c23cce76126920b3ff6710cdb154bdf9c126b8"+ "revision" : "eb1e6628998e47022799d305b52c2680d3576801"}},{diff --git a/Package.swift b/Package.swiftindex 024ed1e5..f519e403 100644--- a/Package.swift+++ b/Package.swift@@ -11,7 +11,7 @@ let package = Package(dependencies: [.package(path: "Vendor/WebRTCAudioProcessing"),.package(url: "https://github.com/mxcl/AppUpdater.git", from: "1.0.0"),- .package(url: "https://github.com/altic-dev/FluidAudio.git", revision: "09c23cce76126920b3ff6710cdb154bdf9c126b8"),+ .package(url: "https://github.com/altic-dev/FluidAudio.git", revision: "eb1e6628998e47022799d305b52c2680d3576801"),.package(url: "https://github.com/mxcl/PromiseKit", from: "6.0.0"),.package(url: "https://github.com/altic-dev/DynamicNotchKit.git", revision: "50dc8565469cc80bbbe3c0d5dd902585a2d67986"),.package(url: "https://github.com/altic-dev/transcribe-cpp-swift.git", exact: "0.1.2"),@@ -37,6 +37,9 @@ let package = Package(.product(name: "TranscribeCpp", package: "transcribe-cpp-swift"),.product(name: "ZeppelinEmbed", package: "zeppelin-embed"),],+ resources: [+ .copy("Resources/speech-model-check.pcm"),+ ],linkerSettings: [.linkedLibrary("sqlite3"),]diff --git a/Sources/Fluid/AppDelegate.swift b/Sources/Fluid/AppDelegate.swiftindex 884c9ead..68e608b9 100644--- a/Sources/Fluid/AppDelegate.swift+++ b/Sources/Fluid/AppDelegate.swift@@ -80,6 +80,12 @@ class AppDelegate: NSObject, NSApplicationDelegate, UNUserNotificationCenterDele_ = FileLogger.sharedTypingService.startKeyboardLayoutTracking()_ = TranscriptionHistoryStore.shared+ #if arch(arm64)+ Task {+ await CompactSpeechModelReleaseCatalog.shared.refreshIfNeeded()+ SpeechModelInstallationSnapshot.shared.refresh()+ }+ #endif#if DEBUGMeetingDetectorFeasibilityProbe.startIfRequested()#endif@@ -107,7 +113,6 @@ class AppDelegate: NSObject, NSApplicationDelegate, UNUserNotificationCenterDeleSettingsStore.shared.bootstrapOnboardingState(isTrueFirstOpen: isTrueFirstOpen)AnalyticsService.shared.bootstrap()- SearchIndexCoordinator.shared.start()// Check for updates automatically if enabled (initial check on launch)self.checkForUpdatesAutomatically()@@ -178,7 +183,9 @@ class AppDelegate: NSObject, NSApplicationDelegate, UNUserNotificationCenterDeleprivate func closeZeppelinForTermination() {var didClose = falseTask {- await FluidZeppelinRoot.shared.closeAll()+ AppSearchService.shared.stop()+ await SearchIndexCoordinator.shared.stop()+ await FluidZeppelinRoot.shared.shutdown()didClose = true}diff --git a/Sources/Fluid/ContentView.swift b/Sources/Fluid/ContentView.swiftindex 533b6df3..6380a96d 100644--- a/Sources/Fluid/ContentView.swift+++ b/Sources/Fluid/ContentView.swift@@ -263,7 +263,10 @@ struct ContentView: View {/// This maintains backward compatibility with the existing code while/// removing the duplicate service instances that cause startup crashes.private var asr: ASRService {- self.appServices.asr+ #if DEBUG+ if let fixture = self.dictationModeSwitchASRForTesting { return fixture }+ #endif+ return self.appServices.asr}private var audioObserver: AudioHardwareObserver {@@ -406,7 +409,55 @@ struct ContentView: View {@State private var columnVisibility: NavigationSplitViewVisibility = .all@State private var toolbarTrailingInset: CGFloat = 80+ #if DEBUG+ private var dictationModeSwitchASRForTesting: ASRService?+ private var dictationModeSwitchOnReadyForTesting: ((ContentView) -> Void)?++ /// Install real SwiftUI state while avoiding the app page's startup/hardware observers.+ static func dictationModeSwitchFixture(+ asr: ASRService,+ hasActiveMode: Bool = true,+ onReady: @escaping (ContentView) -> Void+ ) -> ContentView {+ let commandFixture = CommandModeService()+ var view = ContentView()+ view._commandModeService = StateObject(wrappedValue: commandFixture)+ view.dictationModeSwitchASRForTesting = asr+ view.dictationModeSwitchOnReadyForTesting = onReady+ view._activeRecordingMode = State(initialValue: hasActiveMode ? .edit : .none)+ view._isRecordingForRewrite = State(initialValue: hasActiveMode)+ return view+ }++ func beginDictationModeSwitchForTesting(selection: SettingsStore.DictationPromptSelection? = nil) -> Task<Void, Never>? {+ if let selection { return self.beginDictationRecording(for: selection, mode: .promptMode) }+ return self.beginDictationRecording(for: .primary, mode: .dictate)+ }++ func blockDictationModeSwitchForTesting(savingCancellation: Bool = false, processing: Bool = false) {+ self.isSavingCancelledRecording = savingCancellation+ self.processingDictationLifecycleID = processing ? self.overlayLifecycleID : nil+ }++ var dictationModeSwitchStateForTesting: (mode: String, slot: SettingsStore.DictationShortcutSlot?, generation: UInt64) {+ (self.activeRecordingMode.rawValue, self.activeDictationShortcutSlot, self.overlayLifecycleID)+ }+ #endif++ @ViewBuildervar body: some View {+ #if DEBUG+ if let onReady = self.dictationModeSwitchOnReadyForTesting {+ Color.clear.onAppear { onReady(self) }+ } else {+ self.appBody+ }+ #else+ self.appBody+ #endif+ }++ private var appBody: some View {let layout = AnyView(Group {if self.settings.shouldShowOnboarding {@@ -1490,7 +1541,7 @@ struct ContentView: View {private func open(searchHit hit: AppSearchHit) {switch hit.target {case let .history(id):- TranscriptionHistoryStore.shared.selectedEntryID = id+ TranscriptionHistoryStore.shared.selectEntryFromSearch(id: id)self.navigateToApp(.history)case let .transcript(id):FileTranscriptionHistoryStore.shared.selectedEntryID = id@@ -1997,11 +2048,9 @@ struct ContentView: View {if self.settings.shouldShowOnboarding {return .minimum(width: window.onboardingMinWidth, height: window.onboardingMinHeight)}- return FluidWindowSizing(- minWidth: window.mainMinWidth,- minHeight: window.mainMinHeight,- maximumSize: NSSize(width: 1440, height: 1000)- )+ // Let SwiftUI and the screen choose the upper size; a hard cap can+ // fight the hosting view's content bounds while switching pages.+ return .minimum(width: window.mainMinWidth, height: window.mainMinHeight)}@ViewBuilder@@ -5308,17 +5357,29 @@ extension ContentView {}}+ private var canSwitchActiveDictationCaptureMode: Bool {+ self.activeRecordingMode != .none && self.asr.canSwitchOwnedDictationCaptureMode+ }++ private func canBeginDictationRecording() -> Bool {+ guard !self.isSavingCancelledRecording, self.processingDictationLifecycleID == nil else { return false }+ if self.canSwitchActiveDictationCaptureMode { return true }+ guard !self.presentExclusiveActivityBlockIfNeeded() else { return false }+ return !self.asr.isRunningOrStarting && !self.asr.isDictionaryTrainingCaptureActive+ }+private func beginDictationRecording(for slot: SettingsStore.DictationShortcutSlot,mode: ActiveRecordingMode,startMethod: AnalyticsOnboardingTryoutStartMethod = .hotkey) -> Task<Void, Never>? {- guard !self.isSavingCancelledRecording, self.processingDictationLifecycleID == nil else { return nil }- guard !self.presentExclusiveActivityBlockIfNeeded() else { return nil }+ guard self.canBeginDictationRecording() else { return nil }+ let switchesOwnedCapture = self.canSwitchActiveDictationCaptureMode+ let previousMode = self.activeRecordingModeDebugLogger.shared.debug("Begin dictation recording for slot \(slot.rawValue)", source: "ContentView")DebugLogger.shared.debug("CLOSE_DETAIL nextStartRequested uptime=\(ProcessInfo.processInfo.systemUptime)", source: "StopTiming")self.appBench("begin_recording slot=\(slot.rawValue) mode=\(mode.rawValue)")- if self.isOnboardingVoicePlaygroundStepActive {+ if !switchesOwnedCapture, self.isOnboardingVoicePlaygroundStepActive {self.asr.finalText = ""self.settings.onboardingPlaygroundValidated = falseself.settings.onboardingPlaygroundSkipped = false@@ -5329,6 +5390,17 @@ extension ContentView {self.setActiveRecordingMode(mode)self.rewriteModeService.clearState()+ if switchesOwnedCapture {+ if self.asr.showError, self.asr.errorTitle == "Dictation Unavailable",+ self.asr.errorMessage == "Wait for the active dictation to finish."+ { self.asr.showError = false }+ self.menuBarManager.setOverlayMode(.dictation)+ DebugLogger.shared.info(+ "Dictation capture mode switched from=\(previousMode.rawValue) to=\(mode.rawValue) slot=\(slot.rawValue)",+ source: "ContentView"+ )+ return nil+ }guard !self.asr.isRunningOrStarting else {self.appBench("asr_start_skipped reason=already_running_or_starting")return nil@@ -5383,6 +5455,7 @@ extension ContentView {}private func beginDictationRecording(for selection: SettingsStore.DictationPromptSelection, mode: ActiveRecordingMode) -> Task<Void, Never>? {+ guard self.canBeginDictationRecording() else { return nil }let settings = SettingsStore.sharedsettings.setDictationPromptSelection(selection, for: .secondary)return self.beginDictationRecording(for: .secondary, mode: mode)diff --git a/Sources/Fluid/Networking/CompactSpeechModelArchiveTransport.swift b/Sources/Fluid/Networking/CompactSpeechModelArchiveTransport.swiftnew file mode 100644index 00000000..ab2740d8--- /dev/null+++ b/Sources/Fluid/Networking/CompactSpeechModelArchiveTransport.swift@@ -0,0 +1,342 @@+import Darwin+import Foundation++/// One resumable archive per compact model. All IO and the advisory claim run off main.+nonisolated enum CompactSpeechModelArchiveTransport {+ typealias Progress = @Sendable (Int64, Int64) -> Void+ typealias ChunkTransport = @Sendable (URLRequest, Int64, @escaping @Sendable (Int64) -> Void) async throws -> (URL, URLResponse)+ static let rangeBytes: Int64 = 16 * 1024 * 1024++ enum Failure: LocalizedError, Equatable {+ case invalidDescriptor, invalidRange, alreadyDownloading+ case unsafePartial(URL)++ var errorDescription: String? {+ switch self {+ case .invalidDescriptor: "This compact voice model has no valid pinned download."+ case let .unsafePartial(url): "Voice model download files are unsafe at \(url.path). Remove that file or folder and try again."+ case .invalidRange: "The model server returned an invalid download range. Please try again."+ case .alreadyDownloading: "This voice model is already downloading in another app process. Please try again when it finishes."+ }+ }+ }++ static func download(+ descriptor: ParakeetSpeechModelCatalog.Descriptor,+ in modelsDirectory: URL,+ progress: @escaping Progress,+ transport: ChunkTransport? = nil,+ chunkBytes: Int64 = rangeBytes+ ) async throws -> (URL, URLResponse) {+ let task = Task.detached(priority: .utility) {+ try await self.assemble(descriptor: descriptor, in: modelsDirectory, progress: progress, transport: transport, chunkBytes: chunkBytes)+ }+ return try await withTaskCancellationHandler {+ do { return try await task.value } catch {+ if Task.isCancelled || error is CancellationError { throw CancellationError() }+ throw error+ }+ } onCancel: { task.cancel() }+ }++ private static func assemble(+ descriptor: ParakeetSpeechModelCatalog.Descriptor,+ in modelsDirectory: URL,+ progress: @escaping Progress,+ transport: ChunkTransport?,+ chunkBytes: Int64+ ) async throws -> (URL, URLResponse) {+ try Task.checkCancellation()+ guard descriptor.variant == .mini || descriptor.variant == .pico,+ descriptor.folderName == ParakeetSpeechModelCatalog.descriptor(for: descriptor.variant).folderName,+ modelsDirectory.isFileURL,+ let url = descriptor.archiveURL, url.scheme == "https", url.host == SpeechModelFeed.host,+ url.port == nil, url.user == nil, url.password == nil,+ let hash = descriptor.archiveSHA256, self.validHash(hash),+ descriptor.expectedDownloadBytes > 0, descriptor.expectedDownloadBytes <= 1_000_000_000,+ chunkBytes > 0, chunkBytes <= self.rangeBytes+ else { throw Failure.invalidDescriptor }+ try self.requireDirectory(modelsDirectory)+ let retainedRoot = modelsDirectory.appendingPathComponent(".compact-downloads", isDirectory: true)+ try self.createOwnedDirectory(retainedRoot)+ let directory = retainedRoot.appendingPathComponent(descriptor.folderName, isDirectory: true)+ try self.createOwnedDirectory(directory)+ let claim = try Claim(directory.appendingPathComponent("claim.lock"))+ defer { claim.close() }+ try self.removeAbandonedReadyArchives(in: directory)+ let marker = directory.appendingPathComponent("release.sha256")+ let partial = directory.appendingPathComponent("archive.partial")+ var completed = try self.preparePartial(partial, marker: marker, hash: hash, total: descriptor.expectedDownloadBytes, chunkBytes: chunkBytes)+ let transfer: ChunkTransport = transport ?? { request, maximumBytes, progress in+ try await ChunkLoader.download(request: request, maximumBytes: maximumBytes, progress: progress)+ }+ progress(completed, descriptor.expectedDownloadBytes)+ while completed < descriptor.expectedDownloadBytes {+ try Task.checkCancellation()+ let start = completed+ let end = min(start + chunkBytes, descriptor.expectedDownloadBytes) - 1+ var request = URLRequest(url: url)+ request.timeoutInterval = 60+ request.cachePolicy = .reloadIgnoringLocalAndRemoteCacheData+ request.setValue("bytes=\(start)-\(end)", forHTTPHeaderField: "Range")+ request.setValue("identity", forHTTPHeaderField: "Accept-Encoding")+ var downloaded: URL?+ do {+ let (chunk, response) = try await transfer(request, end - start + 1) { bytes in+ progress(start + max(0, min(bytes, end - start + 1)), descriptor.expectedDownloadBytes)+ }+ downloaded = chunk+ try Task.checkCancellation()+ guard let response = response as? HTTPURLResponse,+ response.statusCode == 206, response.url == url,+ response.value(forHTTPHeaderField: "Content-Range") == "bytes \(start)-\(end)/\(descriptor.expectedDownloadBytes)",+ response.value(forHTTPHeaderField: "Content-Encoding").map({ $0.lowercased() == "identity" }) ?? true,+ try self.fileSize(chunk) == end - start + 1+ else { throw Failure.invalidRange }+ try self.append(chunk: chunk, to: partial, offset: start)+ try Task.checkCancellation()+ completed = end + 1+ try FileManager.default.removeItem(at: chunk)+ downloaded = nil+ progress(completed, descriptor.expectedDownloadBytes)+ } catch {+ // Join transport cancellation before touching its file. Only complete ranges survive.+ if let downloaded { try? FileManager.default.removeItem(at: downloaded) }+ try self.truncate(partial, to: completed)+ throw error+ }+ }+ try Task.checkCancellation()+ // Transfer unique ownership while still holding the claim, so another process+ // cannot resume or replace a completed file the installer is about to consume.+ let ready = directory.appendingPathComponent("ready-\(getpid())-\(UUID().uuidString).tar")+ try FileManager.default.moveItem(at: partial, to: ready)+ // This 200 represents an assembled file, not an HTTP range response. The outer+ // installer still verifies its whole size/SHA before any extraction/publication.+ guard let response = HTTPURLResponse(url: url, statusCode: 200, httpVersion: "HTTP/1.1", headerFields: ["Content-Length": String(descriptor.expectedDownloadBytes)]) else {+ try? FileManager.default.removeItem(at: ready)+ throw Failure.invalidRange+ }+ return (ready, response)+ }++ /// A completed handoff may outlive an app exit before the installer consumes it.+ /// Bound recovery work and never remove another live process's owned handoff.+ private static func removeAbandonedReadyArchives(in directory: URL) throws {+ guard let files = FileManager.default.enumerator(at: directory, includingPropertiesForKeys: nil, options: [.skipsSubdirectoryDescendants]) else {+ throw Failure.unsafePartial(directory)+ }+ var inspected = 0+ for case let file as URL in files {+ try Task.checkCancellation()+ inspected += 1+ guard inspected <= 128 else { break }+ let name = file.lastPathComponent+ guard name.hasPrefix("ready-"), name.hasSuffix(".tar") else { continue }+ let identity = name.dropFirst("ready-".count).dropLast(".tar".count)+ let parts = identity.split(separator: "-", maxSplits: 1)+ guard parts.count == 2,+ let owner = Int32(parts[0]), owner > 0, String(owner) == parts[0],+ let uuid = UUID(uuidString: String(parts[1])), uuid.uuidString == parts[1],+ kill(owner, 0) == -1, errno == ESRCH,+ (try? self.optionalFileSize(file)) != nil+ else { continue }+ try FileManager.default.removeItem(at: file)+ }+ }++ private static func preparePartial(_ partial: URL, marker: URL, hash: String, total: Int64, chunkBytes: Int64) throws -> Int64 {+ let manager = FileManager.default+ let markerSize = try self.optionalFileSize(marker)+ let partialSize = try self.optionalFileSize(partial)+ var sameRelease = false+ if markerSize == 64 {+ let file = try self.openRegular(marker, flags: O_RDONLY)+ defer { try? file.close() }+ let bytes = try file.read(upToCount: 65) ?? Data()+ if let oldHash = String(data: bytes, encoding: .utf8), self.validHash(oldHash) { sameRelease = oldHash == hash }+ }+ if !sameRelease {+ if partialSize != nil { try manager.removeItem(at: partial) }+ if markerSize != nil { try manager.removeItem(at: marker) }+ try Data(hash.utf8).write(to: marker, options: .withoutOverwriting)+ }+ var size = sameRelease ? (partialSize ?? 0) : 0+ if size > total {+ // A crash/corrupted regular partial must have a bounded Retry recovery.+ // The claim and no-link checks restrict repair to this model's owned file.+ try self.truncate(partial, to: 0)+ size = 0+ }+ if try self.optionalFileSize(partial) == nil {+ guard manager.createFile(atPath: partial.path, contents: nil, attributes: [.posixPermissions: 0o600]) else { throw Failure.unsafePartial(partial) }+ }+ let boundary = size == total ? size : (size / chunkBytes) * chunkBytes+ if boundary != size { try self.truncate(partial, to: boundary) }+ return boundary+ }++ private static func append(chunk: URL, to partial: URL, offset: Int64) throws {+ guard try self.fileSize(partial) == offset else { throw Failure.unsafePartial(partial) }+ let input = try self.openRegular(chunk, flags: O_RDONLY)+ defer { try? input.close() }+ let output = try self.openRegular(partial, flags: O_WRONLY)+ defer { try? output.close() }+ try output.seek(toOffset: UInt64(offset))+ while let bytes = try input.read(upToCount: 1_048_576), !bytes.isEmpty {+ try Task.checkCancellation()+ try output.write(contentsOf: bytes)+ }+ try output.synchronize()+ }++ private static func truncate(_ partial: URL, to offset: Int64) throws {+ let file = try self.openRegular(partial, flags: O_WRONLY)+ defer { try? file.close() }+ try file.truncate(atOffset: UInt64(offset))+ try file.synchronize()+ }++ private static func openRegular(_ url: URL, flags: Int32) throws -> FileHandle {+ let descriptor = Darwin.open(url.path, flags | O_NOFOLLOW | O_CLOEXEC)+ guard descriptor >= 0 else { throw Failure.unsafePartial(url) }+ var attributes = stat()+ guard fstat(descriptor, &attributes) == 0, attributes.st_mode & S_IFMT == S_IFREG, attributes.st_nlink == 1 else {+ Darwin.close(descriptor)+ throw Failure.unsafePartial(url)+ }+ return FileHandle(fileDescriptor: descriptor, closeOnDealloc: true)+ }++ private static func fileSize(_ url: URL) throws -> Int64 {+ guard let size = try self.optionalFileSize(url) else { throw Failure.unsafePartial(url) }+ return size+ }++ private static func optionalFileSize(_ url: URL) throws -> Int64? {+ var attributes = stat()+ if lstat(url.path, &attributes) != 0 {+ if errno == ENOENT { return nil }+ throw Failure.unsafePartial(url)+ }+ guard attributes.st_mode & S_IFMT == S_IFREG, attributes.st_nlink == 1, attributes.st_size >= 0 else { throw Failure.unsafePartial(url) }+ return attributes.st_size+ }++ private static func requireDirectory(_ url: URL) throws {+ var attributes = stat()+ guard lstat(url.path, &attributes) == 0, attributes.st_mode & S_IFMT == S_IFDIR else { throw Failure.unsafePartial(url) }+ }++ private static func createOwnedDirectory(_ url: URL) throws {+ if mkdir(url.path, 0o700) != 0, errno != EEXIST { throw Failure.unsafePartial(url) }+ try self.requireDirectory(url)+ }++ private static func validHash(_ hash: String) -> Bool {+ hash.utf8.count == 64 && hash.utf8.allSatisfy { (48...57).contains($0) || (97...102).contains($0) }+ }++ private final class Claim {+ private let descriptor: Int32++ init(_ url: URL) throws {+ let descriptor = Darwin.open(url.path, O_CREAT | O_RDWR | O_NOFOLLOW | O_CLOEXEC, 0o600)+ guard descriptor >= 0 else { throw Failure.unsafePartial(url) }+ var attributes = stat()+ guard fstat(descriptor, &attributes) == 0, attributes.st_mode & S_IFMT == S_IFREG, attributes.st_nlink == 1 else {+ Darwin.close(descriptor)+ throw Failure.unsafePartial(url)+ }+ guard flock(descriptor, LOCK_EX | LOCK_NB) == 0 else {+ Darwin.close(descriptor)+ throw Failure.alreadyDownloading+ }+ self.descriptor = descriptor+ }++ func close() { flock(self.descriptor, LOCK_UN); Darwin.close(self.descriptor) }+ }++ /// Completion joins URLSession's didComplete callback; cancellation never races deletion.+ private final class ChunkLoader: NSObject, URLSessionDownloadDelegate, @unchecked Sendable {+ private let maximumBytes: Int64+ private let progress: @Sendable (Int64) -> Void+ private let lock = NSLock()+ private var continuation: CheckedContinuation<(URL, URLResponse), Error>?+ private var task: URLSessionDownloadTask?+ private var session: URLSession?+ private var result: Result<(URL, URLResponse), Error>?+ private var canceled = false+ private var exceededLimit = false++ init(maximumBytes: Int64, progress: @escaping @Sendable (Int64) -> Void) {+ self.maximumBytes = maximumBytes+ self.progress = progress+ }++ static func download(request: URLRequest, maximumBytes: Int64, progress: @escaping @Sendable (Int64) -> Void) async throws -> (URL, URLResponse) {+ let loader = ChunkLoader(maximumBytes: maximumBytes, progress: progress)+ return try await withTaskCancellationHandler {+ try await withCheckedThrowingContinuation { loader.start(request, continuation: $0) }+ } onCancel: { loader.cancel() }+ }++ private func start(_ request: URLRequest, continuation: CheckedContinuation<(URL, URLResponse), Error>) {+ let configuration = URLSessionConfiguration.ephemeral+ configuration.timeoutIntervalForRequest = 60+ configuration.timeoutIntervalForResource = 600+ let session = URLSession(configuration: configuration, delegate: self, delegateQueue: nil)+ let task = session.downloadTask(with: request)+ let canceled = self.lock.withLock {+ self.continuation = continuation+ self.session = session+ self.task = task+ return self.canceled+ }+ task.resume()+ if canceled { task.cancel() }+ }++ private func cancel() {+ let task = self.lock.withLock { self.canceled = true; return self.task }+ task?.cancel()+ }++ func urlSession(_ session: URLSession, task: URLSessionTask, willPerformHTTPRedirection response: HTTPURLResponse, newRequest request: URLRequest, completionHandler: @escaping (URLRequest?) -> Void) {+ completionHandler(nil)+ }++ func urlSession(_ session: URLSession, downloadTask: URLSessionDownloadTask, didWriteData bytesWritten: Int64, totalBytesWritten: Int64, totalBytesExpectedToWrite: Int64) {+ guard totalBytesWritten <= self.maximumBytes, totalBytesExpectedToWrite <= self.maximumBytes else {+ self.lock.withLock { self.exceededLimit = true }+ downloadTask.cancel()+ return+ }+ self.progress(totalBytesWritten)+ }++ func urlSession(_ session: URLSession, downloadTask: URLSessionDownloadTask, didFinishDownloadingTo location: URL) {+ let result: Result<(URL, URLResponse), Error>+ do {+ guard let response = downloadTask.response, try CompactSpeechModelArchiveTransport.fileSize(location) <= self.maximumBytes else { throw Failure.invalidRange }+ result = try .success((ProgressiveFileDownloader.retainDownloadedFile(at: location), response))+ } catch { result = .failure(error) }+ self.lock.withLock { self.result = result }+ }++ func urlSession(_ session: URLSession, task: URLSessionTask, didCompleteWithError error: Error?) {+ let (continuation, result, exceededLimit) = self.lock.withLock {+ defer { self.continuation = nil; self.result = nil; self.task = nil; self.session = nil }+ return (self.continuation, self.result, self.exceededLimit)+ }+ session.finishTasksAndInvalidate()+ if let error {+ if case let .success((url, _)) = result { try? FileManager.default.removeItem(at: url) }+ continuation?.resume(throwing: exceededLimit ? URLError(.dataLengthExceedsMaximum) : error)+ } else {+ continuation?.resume(with: result ?? .failure(Failure.invalidRange))+ }+ }+ }+}diff --git a/Sources/Fluid/Networking/ModelDownloader.swift b/Sources/Fluid/Networking/ModelDownloader.swiftindex f06ea13b..be80880c 100644--- a/Sources/Fluid/Networking/ModelDownloader.swift+++ b/Sources/Fluid/Networking/ModelDownloader.swift@@ -14,7 +14,7 @@ final class HuggingFaceModelDownloader {let size: Int64?}- struct ModelItem {+ nonisolated struct ModelItem: Sendable {let path: Stringlet isDirectory: Bool}@@ -324,7 +324,7 @@ final class HuggingFaceModelDownloader {}}- static func artifactsAreComplete(root: URL, items: [ModelItem]) -> Bool {+ nonisolated static func artifactsAreComplete(root: URL, items: [ModelItem]) -> Bool {items.allSatisfy { item inSelf.artifactIsComplete(at: root.appendingPathComponent(item.path, isDirectory: item.isDirectory),@@ -333,7 +333,7 @@ final class HuggingFaceModelDownloader {}}- static func artifactIsComplete(at url: URL, isDirectory: Bool) -> Bool {+ nonisolated static func artifactIsComplete(at url: URL, isDirectory: Bool) -> Bool {guard isDirectory else { return self.fileHasContents(at: url) }if url.pathExtension == "mlpackage" {@@ -386,7 +386,7 @@ final class HuggingFaceModelDownloader {return false}- private static func fileHasContents(at url: URL) -> Bool {+ private nonisolated static func fileHasContents(at url: URL) -> Bool {guardlet attributes = try? FileManager.default.attributesOfItem(atPath: url.path),let type = attributes[.type] as? FileAttributeType,@@ -464,7 +464,7 @@ final class HuggingFaceModelDownloader {/// only 512 bytes are read). There is no `URLResponse` for a cached file, so only the/// content is inspected, not a `Content-Type`. Returns `false` (treat as valid) on any/// read error, so an unreadable file is never deleted on uncertainty.- static func cachedFileIsMarkup(at fileURL: URL) -> Bool {+ nonisolated static func cachedFileIsMarkup(at fileURL: URL) -> Bool {guard let handle = try? FileHandle(forReadingFrom: fileURL) else {return false}@@ -531,7 +531,7 @@ final class HuggingFaceModelDownloader {/// catches `<!doctype`, `<html`, `<head>`, `<body>`, `<script>`, `<meta>`, comments/// (`<!-- -->`) and XML / `<?xml` declarations, not just the two prefixes we used to/// match. See issue #353.- static func looksLikeHTML(_ data: Data) -> Bool {+ nonisolated static func looksLikeHTML(_ data: Data) -> Bool {var bytes = [UInt8](data.prefix(512))if bytes.starts(with: [0xef, 0xbb, 0xbf]) {bytes.removeFirst(3)@@ -644,19 +644,23 @@ final nonisolated class ProgressiveFileDownloader: @unchecked Sendable {}}- private final class Delegate: NSObject, URLSessionDownloadDelegate, @unchecked Sendable {+ final class Delegate: NSObject, URLSessionDownloadDelegate, @unchecked Sendable {typealias Completion = @Sendable (Result<(URL, URLResponse), Error>) -> Voidprivate let onProgress: @Sendable (Int64, Int64) -> Void+ private let maximumBytes: Int64?private let lock = NSLock()private var completion: Completion?private var downloadResult: Result<(URL, URLResponse), Error>?+ private var exceededByteLimit = falseweak var session: URLSession?init(+ maximumBytes: Int64?,onProgress: @escaping @Sendable (Int64, Int64) -> Void,completion: @escaping Completion) {+ self.maximumBytes = maximumBytesself.onProgress = onProgressself.completion = completion}@@ -668,6 +672,11 @@ final nonisolated class ProgressiveFileDownloader: @unchecked Sendable {totalBytesWritten: Int64,totalBytesExpectedToWrite: Int64) {+ if let maximumBytes, totalBytesWritten > maximumBytes || totalBytesExpectedToWrite > maximumBytes {+ self.lock.withLock { self.exceededByteLimit = true }+ downloadTask.cancel()+ return+ }self.onProgress(totalBytesWritten, totalBytesExpectedToWrite)}@@ -681,11 +690,26 @@ final nonisolated class ProgressiveFileDownloader: @unchecked Sendable {return}+ self.retainDownload(at: location, response: response)+ }++ @discardableResult+ func retainDownload(at location: URL, response: URLResponse) -> URL? {do {+ if let maximumBytes {+ let attributes = try FileManager.default.attributesOfItem(atPath: location.path)+ guard let size = attributes[.size] as? NSNumber, size.int64Value <= maximumBytes else {+ self.lock.withLock { self.exceededByteLimit = true }+ self.storeResult(.failure(URLError(.dataLengthExceedsMaximum)))+ return nil+ }+ }let retainedURL = try ProgressiveFileDownloader.retainDownloadedFile(at: location)self.storeResult(.success((retainedURL, response)))+ return retainedURL} catch {self.storeResult(.failure(error))+ return nil}}@@ -695,7 +719,14 @@ final nonisolated class ProgressiveFileDownloader: @unchecked Sendable {didCompleteWithError error: Error?) {if let error {- self.finish(.failure(error))+ let retainedFile = self.lock.withLock { () -> URL? in+ defer { self.downloadResult = nil }+ if case let .success((url, _)) = self.downloadResult { return url }+ return nil+ }+ if let retainedFile { try? FileManager.default.removeItem(at: retainedFile) }+ let exceedsLimit = self.lock.withLock { self.exceededByteLimit }+ self.finish(.failure(exceedsLimit ? URLError(.dataLengthExceedsMaximum) : error))} else {let result = self.lock.withLock { self.downloadResult }self.finish(result ?? .failure(URLError(.badServerResponse)))@@ -731,12 +762,14 @@ final nonisolated class ProgressiveFileDownloader: @unchecked Sendable {static func download(from url: URL,configuration: URLSessionConfiguration,+ maximumBytes: Int64? = nil,onProgress: @escaping @Sendable (Int64, Int64) -> Void) async throws -> (URL, URLResponse) {let taskHolder = TaskHolder()return try await withTaskCancellationHandler {try await withCheckedThrowingContinuation { continuation inlet delegate = Delegate(+ maximumBytes: maximumBytes,onProgress: onProgress,completion: { continuation.resume(with: $0) })diff --git a/Sources/Fluid/Networking/ParakeetArchiveDownloader.swift b/Sources/Fluid/Networking/ParakeetArchiveDownloader.swiftnew file mode 100644index 00000000..cbd7278a--- /dev/null+++ b/Sources/Fluid/Networking/ParakeetArchiveDownloader.swift@@ -0,0 +1,308 @@+import Darwin+import Foundation++/// Installs only the descriptor's hash-pinned archive, without changing model selection.+nonisolated enum ParakeetArchiveDownloader {+ typealias Transport = @Sendable (URL, @escaping @Sendable (Int64, Int64) -> Void) async throws -> (URL, URLResponse)+ typealias RevisionWriter = @Sendable (URL, ParakeetSpeechModelCatalog.Descriptor) throws -> Void+ typealias CapacityReader = @Sendable (URL) throws -> Int64+ typealias StageValidator = @Sendable (URL) async throws -> Void+ private static let publicationLock = NSLock()++ private struct InstallationIO: Sendable {+ let transport: Transport?+ let capacityReader: CapacityReader?+ let revisionWriter: RevisionWriter+ }++ private struct InstalledIdentity: Equatable {+ let device: UInt64+ let inode: UInt64+ let revision: String+ }++ enum DownloadError: LocalizedError {+ case invalidDescriptor, invalidResponse, checksumMismatch, invalidArchive, incompleteModel, targetExists+ case cleanupFailed(URL)+ case targetChanged+ case capacityUnavailable+ case insufficientSpace(required: Int64, available: Int64)+ case replacementCleanupFailed(installed: URL, retainedOld: URL)+ case updateFailedWithCleanup(reason: String, installed: URL, temporaryFiles: URL)++ var errorDescription: String? {+ switch self {+ case .invalidDescriptor: return "This voice model has no valid pinned download."+ case .invalidResponse: return "The model server did not return the expected archive. Please try again."+ case .checksumMismatch: return "The downloaded voice model failed verification. Please try again."+ case .invalidArchive: return "The voice model archive contains invalid or unsafe files."+ case .incompleteModel: return "The voice model archive is incomplete."+ case .targetExists: return "A different or incomplete voice model is already cached. Delete this model in Voice Engine settings, then download it again."+ case let .cleanupFailed(url): return "Voice model temporary files could not be removed: \(url.path)"+ case .capacityUnavailable: return "Available disk space could not be checked. Your installed model was kept. Please try again."+ case .insufficientSpace: return "There is not enough free disk space to safely update this voice model. Free some space and try again. Your installed model was kept."+ case .targetChanged: return "The installed voice model changed during this update. Its files were preserved. Please try again."+ case let .replacementCleanupFailed(installed, retainedOld): return "The updated voice model is installed at \(installed.path), but its old files could not be removed: \(retainedOld.path)"+ case let .updateFailedWithCleanup(reason, installed, temporaryFiles):+ return "The voice model update failed: \(reason). "+ + "This update did not replace the installed model at \(installed.path). "+ + "Temporary files could not be removed: \(temporaryFiles.path)"+ }+ }+ }++ static func ensurePresent(+ descriptor: ParakeetSpeechModelCatalog.Descriptor,+ in modelsDirectory: URL,+ progressHandler: @escaping @Sendable (ModelPreparationProgress) -> Void = { _ in },+ replaceExisting: Bool = false,+ stageValidator: StageValidator? = nil,+ transport: Transport? = nil,+ capacityReader: CapacityReader? = nil,+ revisionWriter: @escaping RevisionWriter = { directory, descriptor in try descriptor.writeInstallationRevision(at: directory) }+ ) async throws -> URL {+ let task = Task.detached(priority: .utility) {+ try await self.install(+ descriptor: descriptor,+ modelsDirectory: modelsDirectory,+ progressHandler: progressHandler,+ replaceExisting: replaceExisting,+ stageValidator: stageValidator,+ io: InstallationIO(transport: transport, capacityReader: capacityReader, revisionWriter: revisionWriter)+ )+ }+ return try await withTaskCancellationHandler {+ try await task.value+ } onCancel: {+ task.cancel()+ }+ }++ static func isCleanupFailure(_ error: Error) -> Bool {+ guard let failure = error as? DownloadError else { return false }+ if case .cleanupFailed = failure { return true }+ if case .replacementCleanupFailed = failure { return true }+ if case .updateFailedWithCleanup = failure { return true }+ return false+ }++ private static func install(+ descriptor: ParakeetSpeechModelCatalog.Descriptor,+ modelsDirectory: URL,+ progressHandler: @escaping @Sendable (ModelPreparationProgress) -> Void,+ replaceExisting: Bool,+ stageValidator: StageValidator?,+ io: InstallationIO+ ) async throws -> URL {+ let transport = io.transport+ let capacityReader = io.capacityReader+ let revisionWriter = io.revisionWriter+ try Task.checkCancellation()+ guard self.isComponent(descriptor.folderName), self.isComponent(descriptor.vocabularyFile),+ !descriptor.requiredModelNames.isEmpty,+ descriptor.requiredModelNames.allSatisfy(self.isComponent),+ Set(descriptor.requiredModelNames).count == descriptor.requiredModelNames.count,+ modelsDirectory.isFileURL+ else { throw DownloadError.invalidDescriptor }+ let manager = FileManager.default+ let target = descriptor.cacheDirectory(in: modelsDirectory)+ if self.pathExists(modelsDirectory) { try self.requireDirectory(modelsDirectory) }+ if self.artifactsAreComplete(at: target, descriptor: descriptor) {+ progressHandler(.loading)+ return target+ }+ guard let archiveURL = descriptor.archiveURL, archiveURL.scheme == "https", archiveURL.host != nil,+ let checksum = descriptor.archiveSHA256,+ checksum.count == 64, checksum.utf8.allSatisfy({ (48...57).contains($0) || (97...102).contains($0) }),+ descriptor.expectedDownloadBytes > 0, descriptor.expectedDownloadBytes <= 1_073_741_824+ else { throw DownloadError.invalidDescriptor }+ try manager.createDirectory(at: modelsDirectory, withIntermediateDirectories: true)+ try self.requireDirectory(modelsDirectory)+ let original: InstalledIdentity?+ if self.pathExists(target) {+ guard replaceExisting else { throw DownloadError.targetExists }+ original = try self.installedIdentity(at: target, descriptor: descriptor)+ } else {+ original = nil+ }+ // The old model already consumes disk space; reserve both the tar and its unpacked copy.+ // Runs inside this detached installer, before transport or private staging is created.+ let headroom: Int64 = 32 * 1024 * 1024+ let required = descriptor.expectedDownloadBytes * 2 + headroom+ let available: Int64+ do {+ available = try (capacityReader ?? self.availableCapacity)(modelsDirectory)+ } catch {+ try Task.checkCancellation()+ throw DownloadError.capacityUnavailable+ }+ guard available >= 0 else { throw DownloadError.capacityUnavailable }+ guard available >= required else { throw DownloadError.insufficientSpace(required: required, available: available) }+ try Task.checkCancellation()+ let stage = modelsDirectory.appendingPathComponent(".\(descriptor.folderName)-\(UUID().uuidString).staging", isDirectory: true)+ try manager.createDirectory(at: stage, withIntermediateDirectories: false, attributes: [.posixPermissions: 0o700])+ var retainedDownload: URL?+ do {+ progressHandler(.preparingDownload)+ let transfer: Transport = transport ?? { _, progress in+ try await CompactSpeechModelArchiveTransport.download(descriptor: descriptor, in: modelsDirectory, progress: progress)+ }+ let (downloaded, response) = try await transfer(archiveURL) { bytes, _ in+ let bounded = max(0, min(bytes, descriptor.expectedDownloadBytes))+ progressHandler(.downloading(Double(bounded) / Double(descriptor.expectedDownloadBytes)))+ }+ retainedDownload = downloaded+ try Task.checkCancellation()+ guard let response = response as? HTTPURLResponse, response.statusCode == 200,+ response.url?.scheme == "https",+ try self.regularFileSize(downloaded) == descriptor.expectedDownloadBytes+ else { throw DownloadError.invalidResponse }+ let archive = stage.appendingPathComponent("archive.tar")+ try manager.moveItem(at: downloaded, to: archive)+ retainedDownload = nil+ guard try self.sha256(archive) == checksum else { throw DownloadError.checksumMismatch }+ progressHandler(.optimizing)+ let extraction = stage.appendingPathComponent("extracted", isDirectory: true)+ let extracted = try ParakeetArchiveInstaller.unpack(+ archive: archive,+ folderName: descriptor.folderName,+ staging: extraction,+ manifestSHA256: descriptor.manifestSHA256+ )+ guard self.contentsAreComplete(at: extracted, descriptor: descriptor) else { throw DownloadError.incompleteModel }+ try Task.checkCancellation()+ try revisionWriter(extracted, descriptor)+ try Task.checkCancellation()+ guard self.artifactsAreComplete(at: extracted, descriptor: descriptor) else { throw DownloadError.incompleteModel }+ if let stageValidator { try await stageValidator(extracted) }+ try Task.checkCancellation()+ guard self.artifactsAreComplete(at: extracted, descriptor: descriptor) else { throw DownloadError.incompleteModel }+ // Serialize only publication, not transfers or Core ML validation. Identity+ // and revision checks reject a competing completed update in this process.+ try self.publicationLock.withLock {+ try Task.checkCancellation()+ try self.requireDirectory(modelsDirectory)+ if let original {+ guard try self.installedIdentity(at: target, descriptor: descriptor) == original else { throw DownloadError.targetChanged }+ }+ let result = extracted.withUnsafeFileSystemRepresentation { source in+ target.withUnsafeFileSystemRepresentation { destination in+ renameatx_np(AT_FDCWD, source, AT_FDCWD, destination, UInt32(original == nil ? RENAME_EXCL : RENAME_SWAP))+ }+ }+ guard result == 0 else { throw NSError(domain: NSPOSIXErrorDomain, code: Int(errno)) }+ }+ } catch {+ let originalError = error+ var failedTemporaryURL: URL?+ if let retainedDownload {+ do { try manager.removeItem(at: retainedDownload) } catch { failedTemporaryURL = retainedDownload }+ }+ do { try manager.removeItem(at: stage) } catch { failedTemporaryURL = stage }+ if let failedTemporaryURL {+ if original != nil {+ throw DownloadError.updateFailedWithCleanup(reason: originalError.localizedDescription, installed: target, temporaryFiles: failedTemporaryURL)+ }+ throw DownloadError.cleanupFailed(failedTemporaryURL)+ }+ throw originalError+ }+ do { try manager.removeItem(at: stage) } catch {+ if original != nil { throw DownloadError.replacementCleanupFailed(installed: target, retainedOld: stage) }+ throw DownloadError.cleanupFailed(stage)+ }+ progressHandler(.loading)+ return target+ }++ private static func availableCapacity(at directory: URL) throws -> Int64 {+ if let capacity = try? directory.resourceValues(forKeys: [.volumeAvailableCapacityForImportantUsageKey]).volumeAvailableCapacityForImportantUsage,+ capacity >= 0 { return capacity }+ let attributes = try FileManager.default.attributesOfFileSystem(forPath: directory.path)+ guard let bytes = attributes[.systemFreeSize] as? NSNumber, bytes.int64Value >= 0 else {+ throw DownloadError.capacityUnavailable+ }+ return bytes.int64Value+ }++ private static func installedIdentity(at directory: URL, descriptor: ParakeetSpeechModelCatalog.Descriptor) throws -> InstalledIdentity {+ guard let revision = descriptor.installedArchiveSHA256(at: directory),+ self.contentsAreComplete(at: directory, descriptor: descriptor),+ let attributes = try? FileManager.default.attributesOfItem(atPath: directory.path),+ let device = attributes[.systemNumber] as? NSNumber,+ let inode = attributes[.systemFileNumber] as? NSNumber+ else {+ try Task.checkCancellation()+ throw DownloadError.targetChanged+ }+ return InstalledIdentity(device: device.uint64Value, inode: inode.uint64Value, revision: revision)+ }++ /// Mirrors compiled-artifact readiness while rejecting links anywhere in the tree.+ static func artifactsAreComplete(at directory: URL, descriptor: ParakeetSpeechModelCatalog.Descriptor) -> Bool {+ guard descriptor.installationRevisionMatches(at: directory),+ self.contentsAreComplete(at: directory, descriptor: descriptor)+ else { return false }+ if let manifestSHA256 = descriptor.manifestSHA256 {+ return descriptor.installedManifestSHA256(at: directory) == manifestSHA256+ }+ return true+ }++ private static func contentsAreComplete(at directory: URL, descriptor: ParakeetSpeechModelCatalog.Descriptor) -> Bool {+ do {+ try Task.checkCancellation()+ try self.requireDirectory(directory)+ let manager = FileManager.default+ var enumerationFailed = false+ guard let enumerator = manager.enumerator(at: directory, includingPropertiesForKeys: nil, options: [], errorHandler: { _, _ in+ enumerationFailed = true+ return false+ }) else { return false }+ var count = 0+ for case let url as URL in enumerator {+ try Task.checkCancellation()+ count += 1+ guard count <= 50_000 else { return false }+ let type = try manager.attributesOfItem(atPath: url.path)[.type] as? FileAttributeType+ guard type == .typeDirectory || type == .typeRegular else { return false }+ }+ guard !enumerationFailed else { return false }+ guard try self.regularFileSize(directory.appendingPathComponent(descriptor.vocabularyFile)) > 0 else { return false }+ for name in descriptor.requiredModelNames {+ let model = directory.appendingPathComponent(name, isDirectory: true)+ try self.requireDirectory(model)+ for file in ["coremldata.bin", "metadata.json", "weights/weight.bin"] {+ guard try self.regularFileSize(model.appendingPathComponent(file)) > 0 else { return false }+ }+ }+ return true+ } catch { return false }+ }++ private static func isComponent(_ name: String) -> Bool {+ !name.isEmpty && name != "." && name != ".." && !name.contains("/") && !name.contains("\0")+ }++ private static func pathExists(_ url: URL) -> Bool {+ (try? FileManager.default.attributesOfItem(atPath: url.path)) != nil+ }++ private static func requireDirectory(_ url: URL) throws {+ guard try FileManager.default.attributesOfItem(atPath: url.path)[.type] as? FileAttributeType == .typeDirectory else {+ throw DownloadError.invalidArchive+ }+ }++ private static func regularFileSize(_ url: URL) throws -> Int64 {+ let attributes = try FileManager.default.attributesOfItem(atPath: url.path)+ guard attributes[.type] as? FileAttributeType == .typeRegular, let size = attributes[.size] as? NSNumber else {+ throw DownloadError.invalidArchive+ }+ return size.int64Value+ }++ private static func sha256(_ url: URL) throws -> String {+ try ParakeetArchiveInstaller.sha256(of: url)+ }+}diff --git a/Sources/Fluid/Networking/ParakeetArchiveInstaller.swift b/Sources/Fluid/Networking/ParakeetArchiveInstaller.swiftnew file mode 100644index 00000000..7287c13f--- /dev/null+++ b/Sources/Fluid/Networking/ParakeetArchiveInstaller.swift@@ -0,0 +1,326 @@+import CryptoKit+import Foundation++/// Canonical iPhone/publisher archive checks, with bounded Mac staging and cancellation checks.+/// Mac publication remains in ParakeetArchiveDownloader so a validated update uses an atomic swap.+nonisolated enum ParakeetArchiveInstaller {+ private static let maximumManifestBytes: Int64 = 1_048_576+ private static let maximumFiles = 50_000+ private static let maximumPayloadBytes: Int64 = 1_073_741_824++ private struct Manifest: Decodable {+ struct File: Decodable {+ let path: String+ let size: Int64+ let sha256: String+ }++ let folderName: String+ let totalSize: Int64+ let files: [File]+ }++ enum InstallError: LocalizedError, Equatable {+ case invalidStaging+ case missingFolder+ case manifestMismatch+ case fileMismatch(String)+ case unlistedFile(String)++ var errorDescription: String? {+ switch self {+ case .invalidStaging: "The model staging folder is not safe to use."+ case .missingFolder: "The downloaded model is incomplete."+ case .manifestMismatch: "The downloaded model is not the expected release."+ case let .fileMismatch(path): "The downloaded model failed verification (\(path))."+ case let .unlistedFile(path): "The downloaded model holds an unexpected file (\(path))."+ }+ }+ }++ /// Unpacks into `staging` and returns the model folder. With a manifest hash, every file is proven against it.+ static func unpack(archive: URL, folderName: String, staging: URL, manifestSHA256: String?) throws -> URL {+ try Task.checkCancellation()+ let fileManager = FileManager.default+ guard staging.isFileURL, self.isComponent(folderName),+ (try? fileManager.attributesOfItem(atPath: staging.path)) == nil,+ try fileManager.attributesOfItem(atPath: staging.deletingLastPathComponent().path)[.type]+ as? FileAttributeType == .typeDirectory+ else { throw InstallError.invalidStaging }+ // Only a new, private staging folder may be unpacked. Never remove a caller's existing cache.+ try fileManager.createDirectory(at: staging, withIntermediateDirectories: false, attributes: [.posixPermissions: 0o700])+ try TarExtractor.extract(archive: archive, to: staging)++ let extracted = staging.appendingPathComponent(folderName, isDirectory: true)+ guard (try? fileManager.attributesOfItem(atPath: extracted.path)[.type] as? FileAttributeType) == .typeDirectory,+ try fileManager.contentsOfDirectory(atPath: staging.path) == [folderName]+ else { throw InstallError.missingFolder }+ if let manifestSHA256 {+ try self.verify(folder: extracted, folderName: folderName, manifestSHA256: manifestSHA256)+ }+ return extracted+ }++ static func verify(folder: URL, folderName: String, manifestSHA256: String) throws {+ try Task.checkCancellation()+ let manager = FileManager.default+ guard self.isComponent(folderName), self.isSHA256(manifestSHA256),+ (try? manager.attributesOfItem(atPath: folder.path)[.type] as? FileAttributeType) == .typeDirectory+ else { throw InstallError.manifestMismatch }+ let manifestURL = folder.appendingPathComponent("manifest.json")+ guard let attributes = try? manager.attributesOfItem(atPath: manifestURL.path),+ attributes[.type] as? FileAttributeType == .typeRegular,+ let size = attributes[.size] as? NSNumber,+ size.int64Value > 0, size.int64Value <= maximumManifestBytes,+ try sha256(of: manifestURL) == manifestSHA256,+ let manifest = try? JSONDecoder().decode(Manifest.self, from: Data(contentsOf: manifestURL)),+ manifest.folderName == folderName,+ manifest.files.count <= maximumFiles,+ manifest.totalSize >= 0, manifest.totalSize <= maximumPayloadBytes+ else { throw InstallError.manifestMismatch }++ var total: Int64 = 0+ for file in manifest.files {+ try Task.checkCancellation()+ guard file.size >= 0, file.size <= self.maximumPayloadBytes - total else { throw InstallError.manifestMismatch }+ total += file.size+ }+ guard total == manifest.totalSize else { throw InstallError.manifestMismatch }++ // Check the complete tree before any payload hash; standalone verification must not follow cache links.+ // Relative filenames avoid Foundation's /var versus /private/var URL aliases.+ // Never resolve child links: inspect their actual type before reading any payload.+ var enumerationFailed = false+ guard let enumerator = manager.enumerator(+ at: folder,+ includingPropertiesForKeys: nil,+ options: .producesRelativePathURLs,+ errorHandler: { _, _ in enumerationFailed = true; return false }+ ) else { throw InstallError.manifestMismatch }+ var regularFiles: [String] = []+ var count = 0+ for case let url as URL in enumerator {+ let relativePath = url.relativePath+ try Task.checkCancellation()+ count += 1+ guard count <= self.maximumFiles else { throw InstallError.manifestMismatch }+ let type = try manager.attributesOfItem(atPath: url.path)[.type] as? FileAttributeType+ guard type == .typeRegular || type == .typeDirectory else { throw InstallError.fileMismatch(url.lastPathComponent) }+ if type == .typeRegular { regularFiles.append(relativePath) }+ }++ guard !enumerationFailed else { throw InstallError.manifestMismatch }++ var listed = Set<String>()+ for file in manifest.files {+ try Task.checkCancellation()+ let components = file.path.split(separator: "/", omittingEmptySubsequences: false)+ guard !components.isEmpty, components.allSatisfy({ self.isComponent(String($0)) }),+ self.isSHA256(file.sha256), listed.insert(file.path).inserted+ else { throw InstallError.fileMismatch(file.path) }+ let url = folder.appendingPathComponent(file.path, isDirectory: false)+ let attributes = try? manager.attributesOfItem(atPath: url.path)+ guard attributes?[.type] as? FileAttributeType == .typeRegular,+ (attributes?[.size] as? NSNumber)?.int64Value == file.size,+ try self.sha256(of: url) == file.sha256+ else { throw InstallError.fileMismatch(file.path) }+ }+ for path in regularFiles {+ guard path == "manifest.json" || listed.contains(path) else { throw InstallError.unlistedFile(path) }+ }+ }++ private static func isComponent(_ name: String) -> Bool {+ !name.isEmpty && name != "." && name != ".." && !name.contains("/") && !name.contains("\0")+ }++ private static func isSHA256(_ value: String) -> Bool {+ value.count == 64 && value.utf8.allSatisfy { (48...57).contains($0) || (97...102).contains($0) }+ }++ static func previousURL(for target: URL) -> URL {+ target.deletingLastPathComponent()+ .appendingPathComponent(".\(target.lastPathComponent)-previous", isDirectory: true)+ }++ /// Puts `extracted` at `target`. With `keepPrevious` the model already there is parked, not deleted,+ /// until the new one has proven itself.+ static func swap(extracted: URL, target: URL, keepPrevious: Bool) throws {+ let fileManager = FileManager.default+ let previous = self.previousURL(for: target)+ let hadModel = fileManager.fileExists(atPath: target.path)+ if hadModel {+ if keepPrevious {+ if fileManager.fileExists(atPath: previous.path) {+ try fileManager.removeItem(at: previous)+ }+ try fileManager.moveItem(at: target, to: previous)+ } else {+ try fileManager.removeItem(at: target)+ }+ }+ do {+ try fileManager.moveItem(at: extracted, to: target)+ } catch {+ if hadModel, keepPrevious {+ try? fileManager.moveItem(at: previous, to: target)+ }+ throw error+ }+ }++ static func hasPrevious(for target: URL) -> Bool {+ FileManager.default.fileExists(atPath: self.previousURL(for: target).path)+ }++ /// Throws away the model at `target` and puts the parked one back.+ static func restorePrevious(for target: URL) throws {+ let fileManager = FileManager.default+ let previous = self.previousURL(for: target)+ guard fileManager.fileExists(atPath: previous.path) else { return }+ if fileManager.fileExists(atPath: target.path) {+ try fileManager.removeItem(at: target)+ }+ try fileManager.moveItem(at: previous, to: target)+ }++ static func discardPrevious(for target: URL) {+ try? FileManager.default.removeItem(at: self.previousURL(for: target))+ }++ static func sha256(of file: URL) throws -> String {+ let handle = try FileHandle(forReadingFrom: file)+ defer { try? handle.close() }+ var hasher = SHA256()+ while true {+ try Task.checkCancellation()+ guard let data = try handle.read(upToCount: 1_048_576), !data.isEmpty else { break }+ hasher.update(data: data)+ }+ return hasher.finalize().map { String(format: "%02x", $0) }.joined()+ }+}++nonisolated enum TarExtractor {+ static func extract(archive: URL, to destination: URL) throws {+ let manager = FileManager.default+ guard (try? manager.attributesOfItem(atPath: destination.path)[.type] as? FileAttributeType) == .typeDirectory,+ try manager.contentsOfDirectory(atPath: destination.path).isEmpty,+ let archiveAttributes = try? manager.attributesOfItem(atPath: archive.path),+ archiveAttributes[.type] as? FileAttributeType == .typeRegular,+ let archiveBytes = archiveAttributes[.size] as? NSNumber,+ archiveBytes.int64Value >= 512, archiveBytes.int64Value <= 1_073_741_824+ else { throw Error.truncatedArchive }+ let input = try FileHandle(forReadingFrom: archive)+ defer { try? input.close() }++ var entryCount = 0+ while true {+ try Task.checkCancellation()+ guard let headerData = try input.read(upToCount: 512), headerData.count == 512 else {+ throw Error.truncatedArchive+ }+ let header = [UInt8](headerData)+ if header.allSatisfy({ $0 == 0 }) {+ return+ }++ entryCount += 1+ guard entryCount <= 50_000,+ try self.octal(in: header, range: 148..<156) == header.enumerated().reduce(Int64(0), {+ $0 + Int64((148..<156).contains($1.offset) ? 32 : $1.element)+ })+ else { throw Error.unsupportedEntry }+ let name = try string(in: header, range: 0..<100)+ let prefix = try string(in: header, range: 345..<500)+ let relativePath = prefix.isEmpty ? name : "\(prefix)/\(name)"+ let output = try safeOutputURL(relativePath: relativePath, destination: destination)+ let size = try octal(in: header, range: 124..<136)+ let type = header[156]+ let offset = try input.offset()+ let padding = (512 - (size % 512)) % 512+ guard size >= 0, offset <= archiveBytes.uint64Value,+ UInt64(size) <= archiveBytes.uint64Value - offset,+ UInt64(padding) <= archiveBytes.uint64Value - offset - UInt64(size)+ else { throw Error.truncatedArchive }++ switch type {+ case 0, 48:+ guard (try? manager.attributesOfItem(atPath: output.path)) == nil else { throw Error.unsupportedEntry }+ try FileManager.default.createDirectory(+ at: output.deletingLastPathComponent(),+ withIntermediateDirectories: true+ )+ guard FileManager.default.createFile(atPath: output.path, contents: nil, attributes: [.posixPermissions: 0o600]) else {+ throw Error.cannotCreateFile+ }+ let file = try FileHandle(forWritingTo: output)+ defer { try? file.close() }+ var remaining = size+ while remaining > 0 {+ try Task.checkCancellation()+ let count = Int(min(remaining, 1_048_576))+ guard let data = try input.read(upToCount: count), data.count == count else {+ throw Error.truncatedArchive+ }+ try file.write(contentsOf: data)+ remaining -= Int64(count)+ }+ case 53:+ guard size == 0 else { throw Error.unsupportedEntry }+ try FileManager.default.createDirectory(+ at: output,+ withIntermediateDirectories: true+ )+ case 103, 120:+ // BSD tar emits global/per-file PAX metadata records. Their+ // payload is metadata only; paths remain available in the+ // following ustar header for these model archives.+ let offset = try input.offset()+ try input.seek(toOffset: offset + UInt64(size))+ default:+ throw Error.unsupportedEntry+ }++ try input.seek(toOffset: offset + UInt64(size + padding))+ }+ }++ private static func safeOutputURL(relativePath: String, destination: URL) throws -> URL {+ guard !relativePath.isEmpty, !relativePath.hasPrefix("/") else {+ throw Error.unsafePath+ }+ let components = relativePath.split(separator: "/", omittingEmptySubsequences: true)+ guard !components.isEmpty,+ components.allSatisfy({ $0 != "." && $0 != ".." && !$0.contains("\0") })+ else {+ throw Error.unsafePath+ }+ return components.reduce(destination) { output, component in+ output.appendingPathComponent(String(component), isDirectory: false)+ }+ }++ private static func string(in bytes: [UInt8], range: Range<Int>) throws -> String {+ guard let value = String(bytes: bytes[range].prefix { $0 != 0 }, encoding: .utf8) else { throw Error.unsafePath }+ return value+ }++ private static func octal(in bytes: [UInt8], range: Range<Int>) throws -> Int64 {+ let raw = try string(in: bytes, range: range).trimmingCharacters(in: .whitespaces)+ guard raw.isEmpty || raw.allSatisfy({ ("0"..."7").contains(String($0)) }),+ let value = Int64(raw.isEmpty ? "0" : raw, radix: 8)+ else {+ throw Error.invalidSize+ }+ return value+ }++ private enum Error: Swift.Error {+ case cannotCreateFile+ case invalidSize+ case truncatedArchive+ case unsafePath+ case unsupportedEntry+ }+}diff --git a/Sources/Fluid/Persistence/BackupService.swift b/Sources/Fluid/Persistence/BackupService.swiftindex 7b6a6cf0..a36c30dd 100644--- a/Sources/Fluid/Persistence/BackupService.swift+++ b/Sources/Fluid/Persistence/BackupService.swift@@ -139,6 +139,12 @@ struct SettingsBackupPayload: Codable, Equatable {let defaultEditPromptOverride: String?let fileTranscriptionSpeakerLabelsEnabled: Bool?let fileTranscriptionExpectedSpeakerCount: Int?+ // Additive fields: absence in an older backup preserves current preferences.+ var meetingRecordingDefaults: MeetingRecordingDefaults? = nil+ var privateAIIdleUnload: SettingsStore.PrivateAIIdleUnload? = nil+ // A present empty map clears prompt overrides; an absent map preserves them.+ // swiftlint:disable:next discouraged_optional_collection+ var dictationPromptConfigurations: [String: SettingsStore.DictationPromptConfiguration]? = nil}struct AppBackupDocument: Codable, Equatable {@@ -157,6 +163,7 @@ struct AppBackupDocument: Codable, Equatable {enum BackupServiceError: LocalizedError {case unsupportedSchemaVersion(BackupFileVersion)case invalidJSON+ case operationInProgressvar errorDescription: String? {switch self {@@ -164,6 +171,8 @@ enum BackupServiceError: LocalizedError {return "This backup uses an unsupported schema version (\(version.major).\(version.minor))."case .invalidJSON:return "The selected backup file is not a valid FluidVoice backup."+ case .operationInProgress:+ return "A backup import or export is already running. Wait for it to finish, then try again."}}}@@ -172,11 +181,23 @@ enum BackupServiceError: LocalizedError {final class BackupService {static let shared = BackupService()+ private var operationInProgress = false+private init() {}+ private func beginOperation() throws {+ guard !self.operationInProgress else { throw BackupServiceError.operationInProgress }+ self.operationInProgress = true+ }+func makeBackupDocument() async throws -> AppBackupDocument {+ try self.beginOperation()+ defer { self.operationInProgress = false }+ try Task.checkCancellation()try await TranscriptionHistoryStore.shared.waitUntilLoaded()+ try Task.checkCancellation()let pronunciationProfiles = await PronunciationDictionaryStore.shared.allProfiles()+ try Task.checkCancellation()return AppBackupDocument(schemaVersion: .current,appVersion: Bundle.main.object(forInfoDictionaryKey: "CFBundleShortVersionString") as? String ?? "Unknown",@@ -213,20 +234,41 @@ final class BackupService {}func restore(_ document: AppBackupDocument) async throws {+ try self.beginOperation()+ defer { self.operationInProgress = false }+ try Task.checkCancellation()try self.validate(document)+ let asr = AppServices.shared.asr+ let activityLease = try asr.beginSettingsBackupRestore()+ defer { asr.releaseExclusiveActivity(activityLease) }// A legacy backup represents the complete state from before voice// profiles existed. Restoring it must therefore clear newer profiles// instead of leaving them attached to restored dictionary entry IDs.try await PronunciationDictionaryStore.shared.replaceAllProfiles(document.pronunciationProfiles ?? [])+ // Profile replacement is a synchronous actor write once admitted. Finish+ // the matching settings/History commit even if cancellation arrives during+ // its actor hop; stopping here would leave a partially restored document.+ let previousIdleUnload = SettingsStore.shared.privateAIIdleUnloadSettingsStore.shared.restore(from: document.settings,promptProfiles: document.promptProfiles,appPromptBindings: document.appPromptBindings)+ // Commit settings, History and synchronous observers together before+ // yielding to another actor, keeping the settings/History snapshot consistent.TranscriptionHistoryStore.shared.restore(from: document.transcriptionHistory)+ // Arm model retirement before admission reopens, including imports whose+ // unchanged idle preference has no further actor hop. UI notification+ // delivery must never decide whether the next capture uses stale state.+ asr.handleSettingsBackupDidRestore()NotificationCenter.default.post(name: .settingsBackupDidRestore, object: nil)+ if let idleUnload = document.settings.privateAIIdleUnload, idleUnload != previousIdleUnload {+ // Match the preference UI's targeted rescheduling; do not use the+ // general restore notification to change model timers.+ await PrivateAIIntegrationService.idleUnloader.settingsChanged()+ }}func suggestedFilename(for date: Date = Date()) -> String {diff --git a/Sources/Fluid/Persistence/Search/SearchIndex.swift b/Sources/Fluid/Persistence/Search/SearchIndex.swiftindex 81292c57..9307d115 100644--- a/Sources/Fluid/Persistence/Search/SearchIndex.swift+++ b/Sources/Fluid/Persistence/Search/SearchIndex.swift@@ -4,13 +4,13 @@ import ZeppelinEmbed/// The full-text index behind the sidebar search: one record-only Zeppelin/// namespace per `SearchIndexKind`.///-/// This is a derived copy. The stores in `UserDefaults` remain the source of truth,+/// This is a derived copy. The app's history stores remain the source of truth,/// so a namespace that is missing, reset, or from another build is simply rebuilt/// from its store.////// The one write operation is `reconcile`: compare what the store has with what the/// namespace has, delete the rest, upsert the difference. It is idempotent, so the-/// same call is the launch backfill, the write-through after a change, the cleanup+/// same call is the first-search backfill, the write-through after a change, the cleanup/// after a store evicts rows past its cap, and the recovery after a reset. An/// interrupted run leaves nothing to undo; the next run finishes it.actor SearchIndex {@@ -27,9 +27,11 @@ actor SearchIndex {}private let root: FluidZeppelinRoot+ private let maintenanceActiveRowLimit: UInt64?- init(root: FluidZeppelinRoot = .shared) {+ init(root: FluidZeppelinRoot = .shared, maintenanceActiveRowLimit: UInt64? = 256) {self.root = root+ self.maintenanceActiveRowLimit = maintenanceActiveRowLimit}/// No attributes: there is no filtered lexical query, and grouping is by@@ -82,6 +84,9 @@ actor SearchIndex {_ = try await store.upsert(pending.map(Self.document))report.upserted = pending.count}+ // Finish the document scan before sealing: its cursor belongs to the old+ // generation. Also migrate unchanged indexes left entirely in the WAL.+ await self.sealLargeActiveIndex(store, kind: kind)if report != ReconcileReport() {await DebugLogger.shared.info("Search index \(kind.rawValue): +\(report.upserted) -\(report.deleted)",@@ -91,6 +96,19 @@ actor SearchIndex {return report}+ private func sealLargeActiveIndex(_ store: ZeppelinStore, kind: SearchIndexKind) async {+ guard let limit = self.maintenanceActiveRowLimit else { return }+ do {+ let stats = try await store.stats()+ guard stats.activeRowCount >= limit, stats.activeRowCount > 0 else { return }+ _ = try await store.seal()+ } catch {+ // This is a derived index. Failed maintenance must not turn a+ // successful update into missing results; retry on the next update.+ DebugLogger.shared.warning("Search index \(kind.rawValue) maintenance deferred: \(error)", source: "SearchIndex")+ }+ }+private static func document(_ record: SearchIndexRecord) -> IngestDocument {IngestDocument(id: DocumentID(uuid: record.id),diff --git a/Sources/Fluid/Persistence/Search/SearchIndexCoordinator.swift b/Sources/Fluid/Persistence/Search/SearchIndexCoordinator.swiftindex 7dd4c32f..cd37e2f3 100644--- a/Sources/Fluid/Persistence/Search/SearchIndexCoordinator.swift+++ b/Sources/Fluid/Persistence/Search/SearchIndexCoordinator.swift@@ -1,68 +1,391 @@import Combineimport Foundation-/// Keeps `SearchIndex` equal to the three stores it mirrors.-///-/// Each store publishes its whole array on every change and replays its current-/// snapshot on subscription. History waits until its asynchronous load succeeds,-/// so an incomplete snapshot cannot erase the index. One subscription per store-/// covers the launch backfill and every later change with the same code path.-/// The debounce folds a burst of saves into one reconcile, and reconciles for-/// one kind run in order so two cannot interleave.+/// Mirrors authoritative store snapshots only once search is requested.+/// Each kind retains at most one running snapshot and one replaceable successor.@MainActorfinal class SearchIndexCoordinator {static let shared = SearchIndexCoordinator()+ enum Snapshot {+ case history([TranscriptionHistoryEntry])+ case transcripts([FileTranscriptionEntry])+ case chats([ChatSession])++ var kind: SearchIndexKind {+ switch self {+ case .history: .history+ case .transcripts: .transcripts+ case .chats: .chats+ }+ }+ }++ enum PreparationError: LocalizedError {+ case timedOut++ var errorDescription: String? {+ "Search is taking longer than expected. Please try again."+ }+ }++ private struct PendingSnapshot {+ let generation: UInt64+ let snapshot: Snapshot+ }++ private struct Waiter {+ let id: UUID+ let generation: UInt64+ let continuation: CheckedContinuation<Void, Error>+ let timeout: Task<Void, Never>+ }++ private final class State {+ var generation: UInt64 = 0+ var completedGeneration: UInt64 = 0+ var latest: PendingSnapshot?+ var worker: Task<Void, Never>?+ var debounce: Task<Void, Never>?+ var waiters: [Waiter] = []+ var seeded = false+ var failure: (generation: UInt64, error: Error)?+ var needsRefresh = false+ var suppressedGeneration: UInt64 = 0+ }++ /// Chat metadata stays on the main actor; only immutable text fields cross it.+ private nonisolated struct ChatFields: Sendable {+ let id: UUID+ let revision: UInt64+ let timestamp: Date+ let parts: [String]++ var record: SearchIndexRecord {+ SearchIndexRecord(+ id: self.id,+ revision: self.revision,+ timestamp: self.timestamp,+ text: SearchIndexRecord.joined(self.parts)+ )+ }+ }+private var cancellables: Set<AnyCancellable> = []- private var pending: [SearchIndexKind: Task<Void, Never>] = [:]- private var seeded: Set<SearchIndexKind> = []- private let index: SearchIndex-- init(index: SearchIndex = .shared) {- self.index = index- }-- func start(historyStore: TranscriptionHistoryStore = .shared) {- guard self.cancellables.isEmpty else { return }- // Results join the index against `TranscriptionHistoryStore.entries`, which is- // empty until the load finishes. A query typed before then finds nothing to- // join, and an index already equal to the loaded history reconciles to no- // change, so the first snapshot has to refresh on its own.- self.mirror(- .history,- historyStore.loadedEntriesPublisher.map { $0.map(\.searchRecord) },- refreshOnFirstSnapshot: true+ private var states: [SearchIndexKind: State] = [:]+ private var stopped = false+ private var preparing = 0+ private var historyWaiters: [Waiter] = []+ private var historyLoad: Task<Void, Never>?+ private let preparationTimeout: Duration+ private let reconcile: @Sendable (SearchIndexKind, [SearchIndexRecord]) async throws -> SearchIndex.ReconcileReport+ private let refresh: @MainActor () -> Void++ init(+ index: SearchIndex = .shared,+ reconcile: (@Sendable (SearchIndexKind, [SearchIndexRecord]) async throws -> SearchIndex.ReconcileReport)? = nil,+ refresh: @escaping @MainActor () -> Void = { AppSearchService.shared.refresh() },+ preparationTimeout: Duration = .seconds(20)+ ) {+ self.reconcile = reconcile ?? { kind, records in+ try await index.reconcile(kind, with: records)+ }+ self.refresh = refresh+ self.preparationTimeout = preparationTimeout+ }++ /// Explicit callers retain write-through behavior. Production calls this lazily.+ func start(historyStore: TranscriptionHistoryStore? = nil) {+ guard !self.stopped, self.cancellables.isEmpty else { return }+ let historyStore = historyStore ?? .shared+ // This publisher never treats an incomplete or failed load as empty history.+ historyStore.loadedEntriesPublisher+ .sink { [weak self] in self?.submit(.history($0)) }+ .store(in: &self.cancellables)+ FileTranscriptionHistoryStore.shared.$entries+ .sink { [weak self] in self?.submit(.transcripts($0)) }+ .store(in: &self.cancellables)+ ChatHistoryStore.shared.$sessions+ .sink { [weak self] in self?.submit(.chats($0)) }+ .store(in: &self.cancellables)+ }++ /// The first query waits for complete history and its latest captured index state.+ /// Later edits cannot extend this barrier indefinitely: targets are fixed here.+ func prepareForSearch(historyStore: TranscriptionHistoryStore? = nil) async throws {+ guard !self.stopped else { throw CancellationError() }+ let historyStore = historyStore ?? .shared+ let deadline = ContinuousClock.now.advanced(by: self.preparationTimeout)+ var targets: [SearchIndexKind: UInt64] = [:]+ self.preparing += 1+ defer {+ self.preparing -= 1+ if self.preparing == 0 {+ let missedChange = self.states.contains { kind, state in+ state.suppressedGeneration > (targets[kind] ?? state.generation)+ }+ for state in self.states.values {+ state.suppressedGeneration = 0+ }+ if missedChange, !self.stopped { self.refresh() }+ }+ }+ self.start(historyStore: historyStore)+ try await self.waitForHistory(historyStore, until: deadline)+ try Task.checkCancellation()+ targets = self.states.mapValues(\.generation)+ try await self.waitUntilCurrent(targets: targets, deadline: deadline)+ }++ /// Retains raw values, so a burst never constructs text for discarded snapshots.+ func submit(_ snapshot: Snapshot) {+ guard !self.stopped else { return }+ let kind = snapshot.kind+ let state = self.state(for: kind)+ state.generation &+= 1+ state.latest = PendingSnapshot(generation: state.generation, snapshot: snapshot)+ state.debounce?.cancel()+ state.debounce = Task { [weak self] in+ do { try await Task.sleep(for: .milliseconds(250)) } catch { return }+ guard !Task.isCancelled, let self, !self.stopped else { return }+ state.debounce = nil+ self.startWorker(kind, state: state)+ }+ }++ /// Flushes the debounce without building records on the caller's actor.+ func flush() {+ guard !self.stopped else { return }+ for (kind, state) in self.states {+ state.debounce?.cancel()+ state.debounce = nil+ self.startWorker(kind, state: state)+ }+ }++ /// A bounded barrier for snapshots already received; subsequent edits coalesce.+ func waitUntilCurrent() async throws {+ guard !self.stopped else { throw CancellationError() }+ let targets = self.states.mapValues(\.generation)+ try await self.waitUntilCurrent(+ targets: targets,+ deadline: ContinuousClock.now.advanced(by: self.preparationTimeout))- self.mirror(.transcripts, FileTranscriptionHistoryStore.shared.$entries.map { $0.map(\.searchRecord) })- self.mirror(.chats, ChatHistoryStore.shared.$sessions.map { $0.compactMap(\.searchRecord) })- }-- private func mirror<P: Publisher>(- _ kind: SearchIndexKind,- _ records: P,- refreshOnFirstSnapshot: Bool = false- ) where P.Output == [SearchIndexRecord], P.Failure == Never {- records- .debounce(for: .milliseconds(250), scheduler: DispatchQueue.main)- .sink { [weak self] records in- guard let self else { return }- let isFirstSnapshot = self.seeded.insert(kind).inserted- let previous = self.pending[kind]- self.pending[kind] = Task { [index] in- await previous?.value+ }++ private func waitUntilCurrent(targets: [SearchIndexKind: UInt64], deadline: ContinuousClock.Instant) async throws {+ self.flush()+ for (kind, generation) in targets {+ try Task.checkCancellation()+ try await self.wait(for: generation, kind: kind, deadline: deadline)+ }+ }++ /// Once stopped, this instance cannot reopen namespaces or refresh search again.+ func stop() async {+ self.stopped = true+ self.cancellables.removeAll()+ self.historyLoad?.cancel()+ self.historyLoad = nil+ for waiter in self.historyWaiters {+ waiter.timeout.cancel()+ waiter.continuation.resume(throwing: CancellationError())+ }+ self.historyWaiters.removeAll()+ let workers = self.states.values.compactMap(\.worker)+ for state in self.states.values {+ state.debounce?.cancel()+ state.debounce = nil+ state.latest = nil+ self.finishWaiters(state, through: .max, result: .failure(CancellationError()))+ }+ for worker in workers {+ await worker.value+ }+ }++ private func state(for kind: SearchIndexKind) -> State {+ if let state = self.states[kind] { return state }+ let state = State()+ self.states[kind] = state+ return state+ }++ private func startWorker(_ kind: SearchIndexKind, state: State) {+ guard !self.stopped, state.worker == nil, state.latest != nil else { return }+ state.worker = Task { [weak self] in+ guard let self else { return }+ while !self.stopped, state.debounce == nil, let pending = state.latest {+ state.latest = nil+ state.debounce?.cancel()+ state.debounce = nil+ let records = await self.records(for: pending.snapshot)+ guard !self.stopped else { break }+ do {+ let report = try await self.reconcile(kind, records)+ let first = !state.seeded+ state.seeded = true+ state.completedGeneration = pending.generation+ state.failure = nil+ self.finishWaiters(state, through: pending.generation, result: .success(()))+ state.needsRefresh = state.needsRefresh || report != SearchIndex.ReconcileReport() || (kind == .history && first)+ } catch {+ state.failure = (state.generation, error)+ self.finishWaiters(state, through: state.generation, result: .failure(error))+ DebugLogger.shared.error(+ "Search index \(kind.rawValue) reconcile failed: \(error)",+ source: "SearchIndex"+ )+ // Preserve only the latest raw snapshot for a later retry. Never+ // spin on a failed index or let older input replace newer input.+ if state.latest == nil, !self.stopped { state.latest = pending }+ break+ }+ }+ state.worker = nil+ if state.latest == nil {+ let shouldRefresh = state.needsRefresh+ state.needsRefresh = false+ if shouldRefresh, !self.stopped {+ if self.preparing == 0 {+ self.refresh()+ } else {+ state.suppressedGeneration = state.completedGeneration+ }+ }+ }+ }+ }++ private func records(for snapshot: Snapshot) async -> [SearchIndexRecord] {+ switch snapshot {+ case let .history(entries):+ return await Task.detached(priority: .utility) {+ autoreleasepool { entries.map(\.searchRecord) }+ }.value+ case let .transcripts(entries):+ return await Task.detached(priority: .utility) {+ autoreleasepool { entries.map(\.searchRecord) }+ }.value+ case let .chats(sessions):+ let fields = sessions.compactMap { session -> ChatFields? in+ guard !session.isArchived, let id = UUID(uuidString: session.id) else { return nil }+ var parts = [session.title]+ for message in session.messages {+ parts.append(message.content)+ if let command = message.toolCall?.command { parts.append(command) }+ }+ return ChatFields(+ id: id,+ revision: session.searchRevision ?? UInt64(max(1, session.updatedAt.timeIntervalSince1970 * 1000)),+ timestamp: session.updatedAt,+ parts: parts+ )+ }+ return await Task.detached(priority: .utility) {+ autoreleasepool { fields.map(\.record) }+ }.value+ }+ }++ private func wait(for generation: UInt64, kind: SearchIndexKind, deadline: ContinuousClock.Instant) async throws {+ guard !self.stopped else { throw CancellationError() }+ let state = self.state(for: kind)+ guard state.completedGeneration < generation else { return }+ if state.worker == nil, let failure = state.failure, failure.generation >= generation {+ throw failure.error+ }+ let id = UUID()+ try await withTaskCancellationHandler {+ try await withCheckedThrowingContinuation { (continuation: CheckedContinuation<Void, Error>) in+ if Task.isCancelled || self.stopped {+ continuation.resume(throwing: CancellationError())+ } else {+ state.waiters.append(Waiter(+ id: id,+ generation: generation,+ continuation: continuation,+ timeout: self.timeout(id: id, kind: kind, deadline: deadline)+ ))+ }+ }+ } onCancel: {+ Task { @MainActor [weak self] in+ guard let self, let state = self.states[kind],+ let position = state.waiters.firstIndex(where: { $0.id == id }) else { return }+ let waiter = state.waiters.remove(at: position)+ waiter.timeout.cancel()+ waiter.continuation.resume(throwing: CancellationError())+ }+ }+ }++ private func finishWaiters(_ state: State, through generation: UInt64, result: Result<Void, Error>) {+ let ready = state.waiters.filter { $0.generation <= generation }+ state.waiters.removeAll { $0.generation <= generation }+ for waiter in ready {+ waiter.timeout.cancel()+ waiter.continuation.resume(with: result)+ }+ }++ private func waitForHistory(_ store: TranscriptionHistoryStore, until deadline: ContinuousClock.Instant) async throws {+ guard !self.stopped else { throw CancellationError() }+ let id = UUID()+ try await withTaskCancellationHandler {+ try await withCheckedThrowingContinuation { (continuation: CheckedContinuation<Void, Error>) in+ guard !Task.isCancelled, !self.stopped else {+ continuation.resume(throwing: CancellationError())+ return+ }+ self.historyWaiters.append(Waiter(+ id: id,+ generation: 0,+ continuation: continuation,+ timeout: self.timeout(id: id, kind: nil, deadline: deadline)+ ))+ guard self.historyLoad == nil else { return }+ self.historyLoad = Task { [weak self] in+ let result: Result<Void, Error>do {- let report = try await index.reconcile(kind, with: records)- if report != SearchIndex.ReconcileReport() || (refreshOnFirstSnapshot && isFirstSnapshot) {- AppSearchService.shared.refresh()- }+ try await store.waitUntilLoaded()+ result = .success(())} catch {- DebugLogger.shared.error(- "Search index \(kind.rawValue) reconcile failed: \(error)",- source: "SearchIndex"- )+ result = .failure(error)+ }+ guard let self else { return }+ self.historyLoad = nil+ let waiters = self.historyWaiters+ self.historyWaiters.removeAll()+ for waiter in waiters {+ waiter.timeout.cancel()+ waiter.continuation.resume(with: result)}}}- .store(in: &self.cancellables)+ } onCancel: {+ Task { @MainActor [weak self] in self?.removeWaiter(id: id, kind: nil, error: CancellationError()) }+ }+ }++ private func timeout(id: UUID, kind: SearchIndexKind?, deadline: ContinuousClock.Instant) -> Task<Void, Never> {+ Task { [weak self] in+ do { try await Task.sleep(until: deadline, clock: .continuous) } catch { return }+ guard !Task.isCancelled else { return }+ self?.removeWaiter(id: id, kind: kind, error: PreparationError.timedOut)+ }+ }++ private func removeWaiter(id: UUID, kind: SearchIndexKind?, error: Error) {+ let waiter: Waiter+ if let kind {+ guard let state = self.states[kind], let position = state.waiters.firstIndex(where: { $0.id == id }) else { return }+ waiter = state.waiters.remove(at: position)+ } else {+ guard let position = self.historyWaiters.firstIndex(where: { $0.id == id }) else { return }+ waiter = self.historyWaiters.remove(at: position)+ }+ waiter.timeout.cancel()+ waiter.continuation.resume(throwing: error)}}diff --git a/Sources/Fluid/Persistence/Search/SearchIndexRecord.swift b/Sources/Fluid/Persistence/Search/SearchIndexRecord.swiftindex 3208594e..dd4bbb42 100644--- a/Sources/Fluid/Persistence/Search/SearchIndexRecord.swift+++ b/Sources/Fluid/Persistence/Search/SearchIndexRecord.swift@@ -45,7 +45,7 @@ extension TranscriptionHistoryEntry {////// An entry is immutable, so its revision only moves when a restore replaces the/// id with different text; everything else stays at the revision it was indexed at.- var searchRecord: SearchIndexRecord {+ nonisolated var searchRecord: SearchIndexRecord {SearchIndexRecord(id: self.id,revision: self.searchRevision ?? 1,@@ -60,7 +60,7 @@ extension FileTranscriptionEntry {/// joined together, so indexing both would count every word twice.////// Renaming advances the persisted revision without changing the recording date.- var searchRecord: SearchIndexRecord {+ nonisolated var searchRecord: SearchIndexRecord {SearchIndexRecord(id: self.id,revision: self.searchRevision ?? 1,diff --git a/Sources/Fluid/Persistence/SettingsStore.swift b/Sources/Fluid/Persistence/SettingsStore.swiftindex d9d9f132..580edd9f 100644--- a/Sources/Fluid/Persistence/SettingsStore.swift+++ b/Sources/Fluid/Persistence/SettingsStore.swift@@ -1691,7 +1691,7 @@ final class SettingsStore: ObservableObject {}/// How long the local model may sit unused before its memory is released.- enum PrivateAIIdleUnload: Int, CaseIterable, Identifiable {+ enum PrivateAIIdleUnload: Int, Codable, CaseIterable, Identifiable {case never = 0case tenMinutes = 10case thirtyMinutes = 30@@ -3681,7 +3681,10 @@ final class SettingsStore: ObservableObject {defaultDictationPromptOverride: self.defaultDictationPromptOverride,defaultEditPromptOverride: self.defaultEditPromptOverride,fileTranscriptionSpeakerLabelsEnabled: self.fileTranscriptionSpeakerLabelsEnabled,- fileTranscriptionExpectedSpeakerCount: self.fileTranscriptionExpectedSpeakerCount+ fileTranscriptionExpectedSpeakerCount: self.fileTranscriptionExpectedSpeakerCount,+ meetingRecordingDefaults: self.meetingRecordingDefaults,+ privateAIIdleUnload: self.privateAIIdleUnload,+ dictationPromptConfigurations: self.dictationPromptConfigurations)}@@ -3710,6 +3713,9 @@ final class SettingsStore: ObservableObject {if let privateAIContextTokenLimit = payload.privateAIContextTokenLimit {self.privateAIContextTokenLimit = privateAIContextTokenLimit}+ if let privateAIIdleUnload = payload.privateAIIdleUnload {+ self.privateAIIdleUnload = privateAIIdleUnload+ }self.selectedSpeechModel = payload.selectedSpeechModelif let selectedWhisperLanguageCode = payload.selectedWhisperLanguageCode {self.selectedWhisperLanguageCode = Self.whisperLanguageCode(fromBackupValue: selectedWhisperLanguageCode)@@ -3726,6 +3732,9 @@ final class SettingsStore: ObservableObject {self.meetingTranscriptionBackendID = payload.meetingTranscriptionBackendID.map {MeetingBackendID(rawValue: $0)} ?? .productionDefault+ if let meetingRecordingDefaults = payload.meetingRecordingDefaults {+ self.meetingRecordingDefaults = meetingRecordingDefaults+ }self.primaryDictationShortcuts = payload.primaryDictationShortcuts ?? [payload.hotkeyShortcut]self.promptModeHotkeyShortcut = payload.promptModeHotkeyShortcutself.promptModeShortcutEnabled = payload.promptModeShortcutEnabled@@ -3888,6 +3897,9 @@ final class SettingsStore: ObservableObject {self.customDictionaryEntries = payload.customDictionaryEntriesself.dictationPromptProfiles = promptProfiles+ if let configurations = payload.dictationPromptConfigurations {+ self.dictationPromptConfigurations = configurations+ }self.appPromptBindings = appPromptBindingsself.selectedDictationPromptID = payload.selectedDictationPromptIDself.isDictationPromptOff = payload.dictationPromptOff ?? self.isDictationPromptOff@@ -3906,6 +3918,11 @@ final class SettingsStore: ObservableObject {self.promptModeSelectedPromptID = payload.promptModeSelectedPromptIDself.isSecondaryDictationPromptOff = payload.secondaryDictationPromptOff ?? falseself.normalizePromptSelectionsIfNeeded()+ // Validate imported mappings only after profile migration/normalization.+ // Legacy backups do not own the newer map, so leave it intact when absent.+ if payload.dictationPromptConfigurations != nil {+ self.normalizeDictationPromptConfigurationsIfNeeded()+ }self.purgeRetiredAppleIntelligenceState()}@@ -5050,6 +5067,8 @@ final class SettingsStore: ObservableObject {case parakeetTDT = "parakeet-tdt"case parakeetTDTv2 = "parakeet-tdt-v2"+ case fluidParakeetMini = "fluid-parakeet-mini"+ case fluidParakeetPico = "fluid-parakeet-pico"case parakeetRealtime = "parakeet-realtime"case qwen3Asr = "qwen3-asr"case cohereTranscribeSixBit = "cohere-transcribe-6bit"@@ -5071,6 +5090,16 @@ final class SettingsStore: ObservableObject {case whisperLargeTurbo = "whisper-large-turbo"case whisperLarge = "whisper-large"+ var parakeetDescriptor: ParakeetSpeechModelCatalog.Descriptor? {+ ParakeetSpeechModelCatalog.descriptor(forModelID: self.rawValue)+ }++ /// Relative product ratings for display and sorting, not benchmark accuracy.+ var hasPerformanceRatings: Bool {+ guard let descriptor = self.parakeetDescriptor else { return true }+ return descriptor.performanceRatings != nil+ }+var id: String {rawValue}@@ -5079,8 +5108,7 @@ final class SettingsStore: ObservableObject {var displayName: String {switch self {- case .parakeetTDT: return "Parakeet TDT v3 (Multilingual)"- case .parakeetTDTv2: return "Parakeet TDT v2 (English Only)"+ case .parakeetTDT, .parakeetTDTv2, .fluidParakeetMini, .fluidParakeetPico: return self.parakeetDescriptor?.displayName ?? self.rawValuecase .parakeetRealtime: return "Parakeet Flash (Beta)"case .qwen3Asr: return "Qwen3 ASR (Beta)"case .cohereTranscribeSixBit: return "Cohere Transcribe"@@ -5100,9 +5128,7 @@ final class SettingsStore: ObservableObject {var languageSupport: String {switch self {- case .parakeetTDT:- return "25 Languages"- case .parakeetTDTv2: return "English Only (Higher Accuracy)"+ case .parakeetTDT, .parakeetTDTv2, .fluidParakeetMini, .fluidParakeetPico: return self.parakeetDescriptor?.languageSupport ?? "English Only"case .parakeetRealtime: return "English Only (Live Streaming)"case .qwen3Asr: return "30 Languages"case .cohereTranscribeSixBit: return "14 Languages (Select Manually)"@@ -5116,8 +5142,7 @@ final class SettingsStore: ObservableObject {var downloadSize: String {switch self {- case .parakeetTDT: return "~460.9 MiB"- case .parakeetTDTv2: return "~442.9 MiB"+ case .parakeetTDT, .parakeetTDTv2, .fluidParakeetMini, .fluidParakeetPico: return self.parakeetDescriptor?.downloadSize ?? ""case .parakeetRealtime: return "~428.4 MiB"case .qwen3Asr: return "~2.0 GiB"case .cohereTranscribeSixBit: return "~1.54 GiB"@@ -5137,8 +5162,7 @@ final class SettingsStore: ObservableObject {var expectedDownloadBytes: Int64 {switch self {- case .parakeetTDT: return 483_288_717- case .parakeetTDTv2: return 464_421_712+ case .parakeetTDT, .parakeetTDTv2, .fluidParakeetMini, .fluidParakeetPico: return self.parakeetDescriptor?.expectedDownloadBytes ?? 0case .parakeetRealtime: return 449_190_189case .qwen3Asr: return 2000 * 1024 * 1024case .cohereTranscribeSixBit: return 1_650_748_785@@ -5156,14 +5180,14 @@ final class SettingsStore: ObservableObject {var requiresAppleSilicon: Bool {switch self {- case .parakeetTDT, .parakeetTDTv2, .parakeetRealtime, .qwen3Asr, .cohereTranscribeSixBit, .nemotronOffline, .nemotronStreaming, .nemotronStreaming320: return true+ case .parakeetTDT, .parakeetTDTv2, .fluidParakeetMini, .fluidParakeetPico, .parakeetRealtime, .qwen3Asr, .cohereTranscribeSixBit, .nemotronOffline, .nemotronStreaming, .nemotronStreaming320: return truedefault: return false}}var isWhisperModel: Bool {switch self {- case .parakeetTDT, .parakeetTDTv2, .parakeetRealtime, .qwen3Asr, .cohereTranscribeSixBit, .nemotronOffline, .nemotronStreaming, .nemotronStreaming320, .appleSpeech,+ case .parakeetTDT, .parakeetTDTv2, .fluidParakeetMini, .fluidParakeetPico, .parakeetRealtime, .qwen3Asr, .cohereTranscribeSixBit, .nemotronOffline, .nemotronStreaming, .nemotronStreaming320, .appleSpeech,.appleSpeechAnalyzer: return falsedefault: return true}@@ -5229,7 +5253,7 @@ final class SettingsStore: ObservableObject {/// Requires macOS 15 or later.var requiresMacOS15: Bool {switch self {- case .qwen3Asr, .cohereTranscribeSixBit: return true+ case .fluidParakeetMini, .fluidParakeetPico, .qwen3Asr, .cohereTranscribeSixBit: return truedefault: return false}}@@ -5279,8 +5303,7 @@ final class SettingsStore: ObservableObject {/// Human-readable marketing name for the card UIvar humanReadableName: String {switch self {- case .parakeetTDT: return "Blazing Fast - Multilingual"- case .parakeetTDTv2: return "Blazing Fast - English"+ case .parakeetTDT, .parakeetTDTv2, .fluidParakeetMini, .fluidParakeetPico: return self.parakeetDescriptor?.humanReadableName ?? self.rawValuecase .parakeetRealtime: return "Flash Dictation"case .qwen3Asr: return "Qwen3 - Multilingual"case .cohereTranscribeSixBit: return "Cohere - High Accuracy"@@ -5301,13 +5324,8 @@ final class SettingsStore: ObservableObject {/// One-line description for the card UIvar cardDescription: String {switch self {- case .parakeetTDT:- return "Fast multilingual transcription. Supports Bulgarian, Croatian, Czech, Danish, " +- "Dutch, English, Estonian, Finnish, French, German, Greek, Hungarian, Italian, " +- "Latvian, Lithuanian, Maltese, Polish, Portuguese, Romanian, Russian, Slovak, " +- "Slovenian, Spanish, Swedish, and Ukrainian."- case .parakeetTDTv2:- return "Optimized for English accuracy and fastest transcription."+ case .parakeetTDT, .parakeetTDTv2, .fluidParakeetMini, .fluidParakeetPico:+ return self.parakeetDescriptor?.cardDescription ?? ""case .parakeetRealtime:return "English-only streaming local dictation with low-latency partial text and end-of-utterance detection."case .qwen3Asr:@@ -5342,7 +5360,7 @@ final class SettingsStore: ObservableObject {/// Minimum recommended RAM in GB for this model to run safelyvar requiredMemoryGB: Double {switch self {- case .parakeetTDT, .parakeetTDTv2, .parakeetRealtime:+ case .parakeetTDT, .parakeetTDTv2, .fluidParakeetMini, .fluidParakeetPico, .parakeetRealtime:return 4.0case .qwen3Asr:return 8.0@@ -5386,8 +5404,7 @@ final class SettingsStore: ObservableObject {/// Speed rating (1-5, higher is faster)var speedRating: Int {switch self {- case .parakeetTDT: return 5- case .parakeetTDTv2: return 5+ case .parakeetTDT, .parakeetTDTv2, .fluidParakeetMini, .fluidParakeetPico: return self.parakeetDescriptor?.performanceRatings?.speedRating ?? 0case .parakeetRealtime: return 5case .qwen3Asr: return 3case .cohereTranscribeSixBit: return 3@@ -5407,8 +5424,7 @@ final class SettingsStore: ObservableObject {/// Accuracy rating (1-5, higher is more accurate)var accuracyRating: Int {switch self {- case .parakeetTDT: return 5- case .parakeetTDTv2: return 5+ case .parakeetTDT, .parakeetTDTv2, .fluidParakeetMini, .fluidParakeetPico: return self.parakeetDescriptor?.performanceRatings?.accuracyRating ?? 0case .parakeetRealtime: return 4case .qwen3Asr: return 4case .cohereTranscribeSixBit: return 5@@ -5428,8 +5444,7 @@ final class SettingsStore: ObservableObject {/// Exact speed percentage (0.0 - 1.0) for the liquid barsvar speedPercent: Double {switch self {- case .parakeetTDT: return 1.0- case .parakeetTDTv2: return 1.0+ case .parakeetTDT, .parakeetTDTv2, .fluidParakeetMini, .fluidParakeetPico: return self.parakeetDescriptor?.performanceRatings?.speedPercent ?? 0case .parakeetRealtime: return 1.0case .qwen3Asr: return 0.45case .cohereTranscribeSixBit: return 0.85@@ -5449,8 +5464,7 @@ final class SettingsStore: ObservableObject {/// Exact accuracy percentage (0.0 - 1.0) for the liquid barsvar accuracyPercent: Double {switch self {- case .parakeetTDT: return 0.92- case .parakeetTDTv2: return 0.96+ case .parakeetTDT, .parakeetTDTv2, .fluidParakeetMini, .fluidParakeetPico: return self.parakeetDescriptor?.performanceRatings?.accuracyPercent ?? 0case .parakeetRealtime: return 0.75case .qwen3Asr: return 0.90case .cohereTranscribeSixBit: return 0.98@@ -5472,6 +5486,7 @@ final class SettingsStore: ObservableObject {switch self {case .parakeetTDT: return "FluidVoice Pick"case .parakeetTDTv2: return "FluidVoice Pick"+ case .fluidParakeetMini, .fluidParakeetPico: return "New"case .parakeetRealtime: return "Beta"case .qwen3Asr: return "Beta"case .cohereTranscribeSixBit: return "New"@@ -5484,7 +5499,7 @@ final class SettingsStore: ObservableObject {/// Optimization level for Apple Silicon (for display)var appleSiliconOptimized: Bool {switch self {- case .parakeetTDT, .parakeetTDTv2, .parakeetRealtime, .qwen3Asr, .cohereTranscribeSixBit, .nemotronOffline, .nemotronStreaming, .nemotronStreaming320, .appleSpeechAnalyzer:+ case .parakeetTDT, .parakeetTDTv2, .fluidParakeetMini, .fluidParakeetPico, .parakeetRealtime, .qwen3Asr, .cohereTranscribeSixBit, .nemotronOffline, .nemotronStreaming, .nemotronStreaming320, .appleSpeechAnalyzer:return truedefault:return false@@ -5505,7 +5520,7 @@ final class SettingsStore: ObservableObject {var supportsPronunciationMatching: Bool {#if arch(arm64)switch self {- case .parakeetTDT, .parakeetTDTv2:+ case .parakeetTDT, .parakeetTDTv2, .fluidParakeetMini, .fluidParakeetPico:return truedefault:return false@@ -5557,7 +5572,7 @@ final class SettingsStore: ObservableObject {/// Which provider this model belongs tovar provider: Provider {switch self {- case .parakeetTDT, .parakeetTDTv2, .parakeetRealtime, .nemotronOffline, .nemotronStreaming, .nemotronStreaming320:+ case .parakeetTDT, .parakeetTDTv2, .fluidParakeetMini, .fluidParakeetPico, .parakeetRealtime, .nemotronOffline, .nemotronStreaming, .nemotronStreaming320:return .nvidiacase .appleSpeech, .appleSpeechAnalyzer:return .apple@@ -5580,15 +5595,10 @@ final class SettingsStore: ObservableObject {switch self {case .appleSpeech, .appleSpeechAnalyzer:return true- case .parakeetTDT:- #if canImport(FluidAudio)- return Self.parakeetModelsExist(version: .v3)- #else- return false- #endif- case .parakeetTDTv2:+ case .parakeetTDT, .parakeetTDTv2, .fluidParakeetMini, .fluidParakeetPico:#if canImport(FluidAudio)- return Self.parakeetModelsExist(version: .v2)+ guard let descriptor = self.parakeetDescriptor else { return false }+ return Self.parakeetModelsExist(descriptor: descriptor)#elsereturn false#endif@@ -5649,22 +5659,10 @@ final class SettingsStore: ObservableObject {}#if canImport(FluidAudio)- private static func parakeetModelsExist(version: AsrModelVersion) -> Bool {- let directory = AsrModels.defaultCacheDirectory(for: version)- let vocabulary = directory.appendingPathComponent(ModelNames.ASR.vocabularyFile)- guard- AsrModels.modelsExist(at: directory, version: version),- HuggingFaceModelDownloader.artifactIsComplete(at: vocabulary, isDirectory: false)- else {- return false- }-- return AsrModels.requiredModelNames.allSatisfy { modelName in- HuggingFaceModelDownloader.artifactIsComplete(- at: directory.appendingPathComponent(modelName, isDirectory: true),- isDirectory: true- )- }+ private static func parakeetModelsExist(descriptor: ParakeetSpeechModelCatalog.Descriptor) -> Bool {+ let modelsDirectory = AsrModels.defaultCacheDirectory().deletingLastPathComponent()+ let directory = descriptor.cacheDirectory(in: modelsDirectory)+ return descriptor.artifactsAreComplete(at: directory)}private static func parakeetRealtimeModelsExist() -> Bool {@@ -5686,6 +5684,8 @@ final class SettingsStore: ObservableObject {/// Brand/provider name for the model (NVIDIA, Apple, OpenAI)var brandName: String {switch self {+ case .fluidParakeetMini, .fluidParakeetPico:+ return "FluidVoice"case .parakeetTDT, .parakeetTDTv2, .parakeetRealtime, .nemotronOffline, .nemotronStreaming, .nemotronStreaming320:return "NVIDIA"case .qwen3Asr:@@ -5710,6 +5710,8 @@ final class SettingsStore: ObservableObject {/// Brand color for the provider badgevar brandColorHex: String {switch self {+ case .fluidParakeetMini, .fluidParakeetPico:+ return "#1A75FF" // FluidBrandColors.bluecase .parakeetTDT, .parakeetTDTv2, .parakeetRealtime, .nemotronOffline, .nemotronStreaming, .nemotronStreaming320:return "#76B900"case .qwen3Asr:@@ -6167,7 +6169,7 @@ extension SettingsStore.SpeechModel {switch self {case .parakeetTDT:return "BG, HR, CS, DA, NL, EN, ET, FI, FR, DE, EL, HU, IT, LV, LT, MT, PL, PT, RO, SK, SL, ES, SV, RU, UK"- case .parakeetRealtime:+ case .fluidParakeetMini, .fluidParakeetPico, .parakeetRealtime:return "EN"case .cohereTranscribeSixBit:return "AR, DE, EL, EN, ES, FR, IT, JA, KO, NL, PL, PT, VI, ZH"@@ -6186,6 +6188,8 @@ extension SettingsStore.SpeechModel {return """Bulgarian, Croatian, Czech, Danish, Dutch, English, Estonian, Finnish, French, German, Greek, Hungarian, Italian, Latvian, Lithuanian, Maltese, Polish, Portuguese, Romanian, Slovak, Slovenian, Spanish, Swedish, Russian, and Ukrainian"""+ case .fluidParakeetMini, .fluidParakeetPico:+ return "English"case .cohereTranscribeSixBit:return "Arabic, German, Greek, English, Spanish, French, Italian, Japanese, Korean, Dutch, Polish, Portuguese, Vietnamese, and Mandarin Chinese"case .nemotronOffline, .nemotronStreaming, .nemotronStreaming320:@@ -6342,6 +6346,13 @@ extension SettingsStore {}}+ /// Read only the persisted choice; callers can resolve the fallback off the main thread.+ func storedExternalCoreMLArtifactsPath(for model: SpeechModel) -> String? {+ let paths = self.defaults.dictionary(forKey: Keys.externalCoreMLArtifactsDirectories) as? [String: String] ?? [:]+ guard let path = paths[model.rawValue], !path.isEmpty else { return nil }+ return path+ }+func externalCoreMLArtifactsDirectory(for model: SpeechModel) -> URL? {guard let spec = model.externalCoreMLSpec else { return nil }let paths = self.defaults.dictionary(forKey: Keys.externalCoreMLArtifactsDirectories) as? [String: String] ?? [:]diff --git a/Sources/Fluid/Persistence/TranscriptionHistoryStore.swift b/Sources/Fluid/Persistence/TranscriptionHistoryStore.swiftindex 0598e151..9223fca6 100644--- a/Sources/Fluid/Persistence/TranscriptionHistoryStore.swift+++ b/Sources/Fluid/Persistence/TranscriptionHistoryStore.swift@@ -239,6 +239,12 @@ struct TranscriptionHistoryEntry: Codable, Identifiable, Equatable, Sendable {}}+/// One pending sidebar reveal. Repeated clicks replace it; it is never persisted.+nonisolated struct HistorySearchSelectionRequest: Equatable {+ let token = UUID()+ let entryID: UUID+}+// MARK: - Transcription History Store@MainActor@@ -265,6 +271,18 @@ final class TranscriptionHistoryStore: ObservableObject {}@Published var selectedEntryID: UUID?+ @Published private(set) var searchSelectionRequest: HistorySearchSelectionRequest?++ func selectEntryFromSearch(id: UUID) {+ self.selectedEntryID = id+ self.searchSelectionRequest = HistorySearchSelectionRequest(entryID: id)+ }++ func consumeSearchSelectionRequest(_ request: HistorySearchSelectionRequest) {+ guard self.searchSelectionRequest == request else { return }+ self.searchSelectionRequest = nil+ }+/// Last completed snapshot while a coalesced background refresh is pending./// Rendering must never scan history or schedule work.@Published private(set) var todaySummary = TodaySummary(words: 0, transcriptions: 0)@@ -458,7 +476,7 @@ final class TranscriptionHistoryStore: ObservableObject {func restore(from payload: [TranscriptionHistoryEntry]) {self.audioSaveGeneration &+= 1self.invalidateAutomaticAudioBudgetMeasurement()- let indexed = Dictionary(self.entries.map { ($0.id, $0.searchRecord.revision) }) { first, _ in first }+ let indexed = Dictionary(self.entries.map { ($0.id, $0.searchRevision ?? 1) }) { first, _ in first }self.entries = payload.map { entry invar entry = entry@@ -644,6 +662,12 @@ final class TranscriptionHistoryStore: ObservableObject {)}+ /// Search retries may reload unavailable history, but must never rewrite it.+ func retryLoadingIfNeeded() {+ guard !self.hasLoaded else { return }+ self.retryPersistence()+ }+func retryPersistence() {guard !self.isLoading else { return }guard self.hasLoaded else {diff --git a/Sources/Fluid/Persistence/VoiceEngineLanguageCatalog.swift b/Sources/Fluid/Persistence/VoiceEngineLanguageCatalog.swiftindex d94f8316..374e4d82 100644--- a/Sources/Fluid/Persistence/VoiceEngineLanguageCatalog.swift+++ b/Sources/Fluid/Persistence/VoiceEngineLanguageCatalog.swift@@ -48,7 +48,7 @@ struct VoiceEngineLanguageRoute: Identifiable, Equatable {var badgeText: String? {switch self.model {- case .parakeetTDT, .parakeetTDTv2:+ case .parakeetTDT, .parakeetTDTv2, .fluidParakeetMini, .fluidParakeetPico:return "Optimized for FluidVoice"default:return nil@@ -150,6 +150,11 @@ enum VoiceEngineLanguageCatalog {routes.append(Self.route(language, .parakeetTDT, .automatic))}+ if language.id == "en" {+ routes.append(Self.route(language, .fluidParakeetMini, .automatic))+ routes.append(Self.route(language, .fluidParakeetPico, .automatic))+ }+if let cohereLanguage = Self.cohereLanguage(for: language.id) {routes.append(Self.route(language, .cohereTranscribeSixBit, .cohere(cohereLanguage)))}@@ -223,33 +228,7 @@ enum VoiceEngineLanguageCatalog {"ar",]- nonisolated static let parakeetV3LanguageIDs: Set<String> = [- "bg",- "hr",- "cs",- "da",- "nl",- "en",- "et",- "fi",- "fr",- "de",- "el",- "hu",- "it",- "lv",- "lt",- "mt",- "pl",- "pt",- "ro",- "sk",- "sl",- "es",- "sv",- "ru",- "uk",- ]+ nonisolated static let parakeetV3LanguageIDs = Set(ParakeetSpeechModelCatalog.v3.supportedLanguageCodes)private static let cohereLanguageMap: [String: SettingsStore.CohereLanguage] = ["ar": .arabic,diff --git a/Sources/Fluid/Persistence/Zeppelin/FluidZeppelinRoot.swift b/Sources/Fluid/Persistence/Zeppelin/FluidZeppelinRoot.swiftindex 1aebc143..9510eba5 100644--- a/Sources/Fluid/Persistence/Zeppelin/FluidZeppelinRoot.swift+++ b/Sources/Fluid/Persistence/Zeppelin/FluidZeppelinRoot.swift@@ -16,6 +16,7 @@ actor FluidZeppelinRoot {private let root: URLprivate var namespaces: [String: Task<ZeppelinStore, Error>] = [:]+ private var stopped = falseinit(root: URL? = nil) {self.root = root ?? FileManager.default@@ -28,6 +29,7 @@ actor FluidZeppelinRoot {/// A second open of the same directory fails on its writer lock, so the open is/// cached as a task: concurrent first callers share one open instead of racing.func namespace(_ name: String, spec: NamespaceSpec) async throws -> ZeppelinStore {+ guard !self.stopped else { throw CancellationError() }if let open = self.namespaces[name] {return try await open.value}@@ -55,8 +57,8 @@ actor FluidZeppelinRoot {}}- /// Closes every open namespace so their logs are checkpointed rather than- /// replayed on the next launch. Called from `applicationWillTerminate`.+ /// Closes cached handles. This is reusable; app termination uses `shutdown`.+ /// SearchIndex seals large active indexes before closure to avoid WAL replay.func closeAll() async {for (name, open) in self.namespaces {do {@@ -70,4 +72,10 @@ actor FluidZeppelinRoot {}self.namespaces.removeAll()}++ /// App termination permanently rejects new opens before draining old ones.+ func shutdown() async {+ self.stopped = true+ await self.closeAll()+ }}diff --git a/Sources/Fluid/Resources/speech-model-check.pcm b/Sources/Fluid/Resources/speech-model-check.pcmnew file mode 100644index 00000000..5a92558eBinary files /dev/null and b/Sources/Fluid/Resources/speech-model-check.pcm differdiff --git a/Sources/Fluid/Services/ASRService.swift b/Sources/Fluid/Services/ASRService.swiftindex 6c1c6457..24dcaab6 100644--- a/Sources/Fluid/Services/ASRService.swift+++ b/Sources/Fluid/Services/ASRService.swift@@ -364,6 +364,7 @@ enum ASRExclusiveActivity: String, Equatable {case localAPIcase meetingcase modelMaintenance+ case settingsRestorevar displayName: String {switch self {@@ -377,6 +378,8 @@ enum ASRExclusiveActivity: String, Equatable {return "meeting transcription"case .modelMaintenance:return "voice model maintenance"+ case .settingsRestore:+ return "settings import"}}}@@ -388,11 +391,14 @@ struct ASRActivityLease: Equatable {enum ASRActivityError: LocalizedError {case activityInProgress(ASRExclusiveActivity)+ case settingsRestoreUnavailablevar errorDescription: String? {switch self {case let .activityInProgress(activity):return "Wait for the active \(activity.displayName) to finish."+ case .settingsRestoreUnavailable:+ return "Finish the current recording, transcription, microphone preview, or voice model operation, then import the backup again."}}}@@ -652,6 +658,15 @@ final class ASRService: ObservableObject {self.isRunning || self.isStarting}+ /// Change only the output mode of our existing capture, never another activity's audio.+ var canSwitchOwnedDictationCaptureMode: Bool {+ guard let lease = self.dictationActivityLease else { return false }+ return lease.activity == .dictation && self.activeActivityLease == lease+ && self.isRunning && !self.isStarting && !self.isStoppingFinalTranscription+ && !self.isTerminating && !self.isDictionaryTrainingCaptureActive+ && !self.recordingBufferHandoffGate.isActive && !self.recordingBufferHandoffGate.isRecovering+ }+func acquireExclusiveActivity(_ activity: ASRExclusiveActivity) throws -> ASRActivityLease {guard let activeActivityLease = self.activeActivityLease else {DictionaryAudioLearningService.shared.cancelForRecording()@@ -663,6 +678,23 @@ final class ASRService: ObservableObject {throw ASRActivityError.activityInProgress(activeActivityLease.activity)}+ /// Reject before any backup writes, then reserve admission across its actor hop.+ /// Keep the whole import together instead of changing the current capture's settings.+ func beginSettingsBackupRestore() throws -> ASRActivityLease {+ try Task.checkCancellation()+ guard !self.isTerminating, self.activeActivityLease == nil,+ !self.isRunning, !self.isStarting, !self.isStoppingFinalTranscription,+ !self.recordingBufferHandoffGate.isRecovering,+ !self.isMicrophonePreviewRequested, !self.isMicrophonePreviewActive,+ !self.hasActiveModelDownload, !self.hasActiveModelPreparation,+ self.deletingModelID == nil, self.providerResetDrain == nil,+ !self.isCancellingModelPreparation, !self.isCancellingModelDownload,+ !self.meetingModelResidency.isExclusive,+ self.isAsrReady || (!self.isDownloadingModel && !self.isLoadingModel)+ else { throw ASRActivityError.settingsRestoreUnavailable }+ return try self.acquireExclusiveActivity(.settingsRestore)+ }+func releaseExclusiveActivity(_ lease: ASRActivityLease) {guard self.activeActivityLease == lease else { return }if self.isMeetingASRClaimBlocking(lease: lease) {@@ -853,7 +885,6 @@ final class ASRService: ObservableObject {private var lastBoostHitTerm: String?private var hasPendingParakeetVocabularyReload: Bool = falseprivate var vocabularyChangeObserver: NSObjectProtocol?- private var settingsBackupRestoreObserver: NSObjectProtocol?private var clamshellStateChangeObserver: NSObjectProtocol?private var inputDeviceAvailabilityChangeObserver: NSObjectProtocol?@@ -934,6 +965,24 @@ final class ASRService: ObservableObject {)}+ func configureDictationModeSwitchForTesting(+ ownedLease: ASRActivityLease?,+ starting: Bool = false,+ finalizing: Bool = false,+ dictionaryTraining: Bool = false+ ) {+ self.dictationActivityLease = ownedLease+ self.isStarting = starting+ self.isStoppingFinalTranscription = finalizing+ self.isDictionaryTrainingCaptureActive = dictionaryTraining+ }++ func beginDictationBufferDrainForTesting(recovering: Bool = false) -> (() -> Void)? {+ guard let token = self.recordingBufferHandoffGate.begin() else { return nil }+ if recovering { self.recordingBufferHandoffGate.markTimedOut(token) }+ return { self.recordingBufferHandoffGate.complete(token) }+ }+func finishAudioRouteRecoveryTest() async {await self.cancelAudioRouteRecoveryAndWait()self.isRunning = false@@ -1002,6 +1051,11 @@ final class ASRService: ObservableObject {@Published private(set) var deletingModelID: String?#if DEBUGvar modelProvidersForTesting: [SettingsStore.SpeechModel: TranscriptionProvider] = [:]++ func prepareProviderRecoveryForTesting(_ provider: TranscriptionProvider, modelsAlreadyCached: Bool) async throws {+ try await self.prepareProviderWithRecovery(provider: provider, modelsAlreadyCached: modelsAlreadyCached, progressHandler: { _ in })+ }+#endifvar hasActiveModelPreparation: Bool {@@ -1112,7 +1166,7 @@ final class ASRService: ObservableObject {}case .appleSpeech:return self.getAppleSpeechProvider()- case .parakeetTDT, .parakeetTDTv2:+ case .parakeetTDT, .parakeetTDTv2, .fluidParakeetMini, .fluidParakeetPico:return self.getFluidAudioProvider()case .parakeetRealtime:return self.getParakeetRealtimeProvider()@@ -1231,7 +1285,7 @@ final class ASRService: ObservableObject {/// Gets a provider for a specific model (without changing the active selection)/// Used for downloading models without switching the active model.- private func getProvider(for model: SettingsStore.SpeechModel) -> TranscriptionProvider {+ private func getProvider(for model: SettingsStore.SpeechModel, updateWeights: Bool = false) -> TranscriptionProvider {#if DEBUGif let injected = self.modelProvidersForTesting[model] { return injected }#endif@@ -1244,9 +1298,9 @@ final class ASRService: ObservableObject {}case .appleSpeech:return AppleSpeechProvider()- case .parakeetTDT, .parakeetTDTv2:+ case .parakeetTDT, .parakeetTDTv2, .fluidParakeetMini, .fluidParakeetPico:// Create a new provider configured for the specific model- return FluidAudioProvider(modelOverride: model, configureWordBoosting: false)+ return FluidAudioProvider(modelOverride: model, configureWordBoosting: false, updateCompactWeights: updateWeights)case .parakeetRealtime:return ParakeetRealtimeProvider()case .cohereTranscribeSixBit:@@ -1269,8 +1323,31 @@ final class ASRService: ObservableObject {func downloadModel(_ model: SettingsStore.SpeechModel,source: AnalyticsModelDownloadSource = .settings,+ updateWeights: Bool = false,progressHandler: ((Double) -> Void)?) async throws {+ try Task.checkCancellation()+ let updateLease: ASRActivityLease?+ if updateWeights {+ guard model == .fluidParakeetMini || model == .fluidParakeetPico else {+ throw NSError(domain: "ASRService", code: -2003, userInfo: [NSLocalizedDescriptionKey: "Only Mini and Pico support weight updates."])+ }+ guard !self.isTerminating, !self.isRunning, !self.isStarting, !self.isStoppingFinalTranscription,+ !self.recordingBufferHandoffGate.isActive, !self.recordingBufferHandoffGate.isRecovering,+ !self.isMicrophonePreviewRequested, !self.isMicrophonePreviewActive, !self.isDictionaryTrainingCaptureActive,+ self.providerResetDrain == nil, !self.isCancellingModelPreparation, !self.isCancellingModelDownload,+ !self.meetingModelResidency.isExclusive+ else {+ throw ASRActivityError.activityInProgress(self.activeExclusiveActivity ?? .modelMaintenance)+ }+ updateLease = try self.acquireExclusiveActivity(.modelMaintenance)+ } else {+ updateLease = nil+ }+ defer { if let updateLease { self.releaseExclusiveActivity(updateLease) } }+ guard self.activeExclusiveActivity != .settingsRestore else {+ throw ASRActivityError.activityInProgress(.settingsRestore)+ }let admission = try self.meetingModelResidency.beginOperation(owner: "speech", modelID: model.id)defer { self.meetingModelResidency.endOperation(admission) }if self.isMeetingASRPreparationClaimed {@@ -1285,7 +1362,7 @@ final class ASRService: ObservableObject {}let operationID = UUID()- let provider = self.getProvider(for: model)+ let provider = self.getProvider(for: model, updateWeights: updateWeights)self.modelDownloadOperationID = operationIDself.downloadingModelId = model.idself.downloadProgress = nil@@ -1314,11 +1391,12 @@ final class ASRService: ObservableObject {)}})- try Task.checkCancellation()+ if !updateWeights { try Task.checkCancellation() }DebugLogger.shared.info("Model download completed: \(model.displayName)", source: "ASRService")} catch {+ if ParakeetArchiveDownloader.isCleanupFailure(error) { throw error }let wasCancelled = Task.isCancelled || Self.isModelPreparationCancellation(error)- if wasCancelled,+ if wasCancelled, !updateWeights,provider.shouldClearCacheAfterCancellation,provider.modelsExistOnDisk() == false{@@ -1340,6 +1418,7 @@ final class ASRService: ObservableObject {self.downloadProgress = nilself.modelPreparationPhase = nilself.isCancellingModelDownload = false+ SpeechModelInstallationSnapshot.shared.refresh()}}@@ -1349,11 +1428,22 @@ final class ASRService: ObservableObject {} onCancel: {task.cancel()}+ if updateWeights, SettingsStore.shared.selectedSpeechModel == model {+ // Release the update lease only after progress and operation cleanup;+ // the normal deferred reset then retires the old active checkpoint.+ self.providerResetPending = true+ }self.finishModelDownloadAnalytics(operationID: operationID, outcome: .succeeded)} catch is CancellationError {self.finishModelDownloadAnalytics(operationID: operationID, outcome: .cancelled)throw CancellationError()} catch {+ if updateWeights, SettingsStore.shared.selectedSpeechModel == model,+ let failure = error as? ParakeetArchiveDownloader.DownloadError,+ case .replacementCleanupFailed = failure+ {+ self.providerResetPending = true+ }self.finishModelDownloadAnalytics(operationID: operationID, outcome: .failed)throw error}@@ -1402,10 +1492,16 @@ final class ASRService: ObservableObject {}let resetDrainID = UUID()let executor = self.transcriptionExecutor- let resetDrainTask = Task { await executor.cancelAndAwaitPending() }+ let resetDrainTask = Task { @MainActor [weak self] in+ await executor.cancelAndAwaitPending()+ // A completed handle must not leave future imports permanently busy.+ if self?.providerResetDrain?.id == resetDrainID {+ self?.providerResetDrain = nil+ }+ }self.providerResetDrain = (resetDrainID, resetDrainTask)- // Keep the task handle until its provider has stopped and cancellation cleanup has- // completed. The next ensureAsrReady call waits for it before touching the same cache.+ // ensureAsrReady joins this executor drain. The retiring preparation task+ // separately remains retained until its provider cancellation cleanup finishes.self.ensureReadyProviderKey = nilself.ensureReadyOperationID = nilself.lastBoostHitTerm = nil@@ -2168,19 +2264,6 @@ final class ASRService: ObservableObject {self?.handleParakeetVocabularyDidChange()}}- self.settingsBackupRestoreObserver = NotificationCenter.default.addObserver(- forName: .settingsBackupDidRestore,- object: nil,- queue: .main- ) { [weak self] _ in- Task { @MainActor [weak self] in- self?.scheduleAudioRouteRecovery(- reason: "settings backup restored",- requiresIdlePrewarm: true,- reconcilesInputSelection: true- )- }- }self.clamshellStateChangeObserver = NotificationCenter.default.addObserver(forName: .clamshellStateDidChange,object: nil,@@ -2210,9 +2293,6 @@ final class ASRService: ObservableObject {if let observer = self.engineConfigurationChangeObserver {NotificationCenter.default.removeObserver(observer)}- if let observer = self.settingsBackupRestoreObserver {- NotificationCenter.default.removeObserver(observer)- }if let observer = self.clamshellStateChangeObserver {NotificationCenter.default.removeObserver(observer)}@@ -2248,6 +2328,20 @@ final class ASRService: ObservableObject {)}+ @MainActor+ func handleSettingsBackupDidRestore() {+ // BackupService calls this synchronously while settingsRestore holds admission.+ // Its release consumes the pending reset before a new capture can enter.+ // Downloaded model files remain intact.+ self.resetTranscriptionProvider()+ SpeechModelInstallationSnapshot.shared.refresh()+ self.scheduleAudioRouteRecovery(+ reason: "settings backup restored",+ requiresIdlePrewarm: true,+ reconcilesInputSelection: true+ )+ }+@MainActorprivate func handleParakeetVocabularyDidChange() {let model = SettingsStore.shared.selectedSpeechModel@@ -2412,6 +2506,8 @@ final class ASRService: ObservableObject {} else {exists = self.getAppleSpeechProvider().modelsExistOnDisk()}+ } else if model == .fluidParakeetMini || model == .fluidParakeetPico {+ exists = (try? await self.modelArtifactsExist(provider: self.transcriptionProvider)) ?? false} else {exists = model.isInstalled}@@ -2457,6 +2553,7 @@ final class ASRService: ObservableObject {self.isRunning == false,self.isStarting == false,self.activeExclusiveActivity != .meeting,+ self.activeExclusiveActivity != .settingsRestore,self.isTerminating == falseelse { return }@@ -2475,6 +2572,7 @@ final class ASRService: ObservableObject {self.isRunning == false,self.isStarting == false,self.activeExclusiveActivity != .meeting,+ self.activeExclusiveActivity != .settingsRestore,self.isTerminating == false,Task.isCancelled == falseelse {@@ -2494,6 +2592,7 @@ final class ASRService: ObservableObject {self.isRunning == false,self.isStarting == false,self.activeExclusiveActivity != .meeting,+ self.activeExclusiveActivity != .settingsRestore,self.isTerminating == false,Task.isCancelled == falseelse {@@ -2520,6 +2619,7 @@ final class ASRService: ObservableObject {self.isRunning == false,self.isStarting == false,self.activeExclusiveActivity != .meeting,+ self.activeExclusiveActivity != .settingsRestore,self.isTerminating == falseelse { throw CancellationError() }_ = try await self.directAudioLifecycleController.start(@@ -2532,6 +2632,7 @@ final class ASRService: ObservableObject {self.isRunning == false,self.isStarting == false,self.activeExclusiveActivity != .meeting,+ self.activeExclusiveActivity != .settingsRestore,self.isTerminating == falseelse { throw CancellationError() }self.activeAudioCaptureBackend = .directCoreAudio@@ -3971,7 +4072,8 @@ final class ASRService: ObservableObject {guard let self, !self.isTerminating,SettingsStore.shared.selectedSpeechModel.id == model.id else { return }// Never download a missing model just to restore residency.- guard self.transcriptionProvider.modelsExistOnDisk() else { return }+ guard try await self.modelArtifactsExist(provider: self.transcriptionProvider),+ !self.isTerminating, SettingsStore.shared.selectedSpeechModel.id == model.id else { return }try await self.ensureAsrReady()if SettingsStore.shared.selectedSpeechModel.id != model.id,let lease = self.activeActivityLease@@ -6262,6 +6364,9 @@ final class ASRService: ObservableObject {progressHandler: ((Double) -> Void)? = nil) async throws {try Task.checkCancellation()+ guard self.activeExclusiveActivity != .settingsRestore else {+ throw ASRActivityError.activityInProgress(.settingsRestore)+ }let admission = try self.meetingModelResidency.beginOperation(owner: "speech", modelID: SettingsStore.shared.selectedSpeechModel.id)@@ -6315,6 +6420,9 @@ final class ASRService: ObservableObject {}}+ guard self.activeExclusiveActivity != .settingsRestore else {+ throw ASRActivityError.activityInProgress(.settingsRestore)+ }guard self.deletingModelID == nil, SettingsStore.shared.selectedSpeechModel == model else {throw CancellationError()}@@ -6356,6 +6464,15 @@ final class ASRService: ObservableObject {}}+ private func modelArtifactsExist(provider: TranscriptionProvider) async throws -> Bool {+ #if arch(arm64)+ if let compactProvider = provider as? FluidAudioProvider {+ return try await compactProvider.refreshModelsExistOnDiskAsync()+ }+ #endif+ return provider.modelsExistOnDisk()+ }+private func performEnsureAsrReady(provider: TranscriptionProvider,operationID: UUID,@@ -6376,13 +6493,17 @@ final class ASRService: ObservableObject {return}+ defer { SpeechModelInstallationSnapshot.shared.refresh() }+// If the flag is set but provider isn't ready (e.g., provider switch without reset), re-init.if self.isAsrReady, !provider.isReady {DebugLogger.shared.debug("ASR marked ready but provider not ready; re-initializing", source: "ASRService")}self.isAsrReady = false- let modelsAlreadyCached = provider.modelsExistOnDisk()+ let modelsAlreadyCached = try await self.modelArtifactsExist(provider: provider)+ try Task.checkCancellation()+ guard self.ensureReadyOperationID == operationID else { throw CancellationError() }let totalStartTime = Date()do {@@ -6515,7 +6636,7 @@ final class ASRService: ObservableObject {}throw CancellationError()} catch {- if Task.isCancelled || Self.isModelPreparationCancellation(error) {+ if !ParakeetArchiveDownloader.isCleanupFailure(error), Task.isCancelled || Self.isModelPreparationCancellation(error) {self.finishModelDownloadAnalytics(operationID: operationID, outcome: .cancelled)if provider.shouldClearCacheAfterCancellation,provider.modelsExistOnDisk() == false@@ -6652,9 +6773,17 @@ final class ASRService: ObservableObject {)return} catch {+ // Staging cleanup failure must not delete a successfully published cache+ // or hide its repair path when cancellation was also requested.+ if ParakeetArchiveDownloader.isCleanupFailure(error) { throw error }if Task.isCancelled || Self.isModelPreparationCancellation(error) {throw CancellationError()}+ if let compact = provider as? FluidAudioProvider, compact.preservesInstalledCompactWeights {+ // Repairing by deletion could silently upgrade an installed older+ // checkpoint. Explicit Update/Delete owns that choice instead.+ throw error+ }firstError = errorDebugLogger.shared.error("ASRService: First prepare attempt for \(provider.name) failed after \(String(format: "%.2f", Date().timeIntervalSince(start)))s", source: "ASRService")DebugLogger.shared.warning(@@ -6692,6 +6821,7 @@ final class ASRService: ObservableObject {do {try await provider.prepare(progressHandler: progressHandler)} catch {+ if ParakeetArchiveDownloader.isCleanupFailure(error) { throw error }if Task.isCancelled || Self.isModelPreparationCancellation(error) {throw CancellationError()}@@ -6771,6 +6901,7 @@ final class ASRService: ObservableObject {let isActive = SettingsStore.shared.selectedSpeechModel == modeldefer {self.deletingModelID = nil+ SpeechModelInstallationSnapshot.shared.refresh()self.releaseExclusiveActivity(activityLease)}DebugLogger.shared.debug("Clearing model cache for \(model.displayName)", source: "ASRService")diff --git a/Sources/Fluid/Services/AppSearch/AppSearchService.swift b/Sources/Fluid/Services/AppSearch/AppSearchService.swiftindex 8f3dec56..9e64466d 100644--- a/Sources/Fluid/Services/AppSearch/AppSearchService.swift+++ b/Sources/Fluid/Services/AppSearch/AppSearchService.swift@@ -60,7 +60,12 @@ nonisolated struct AppSearchGroup: Identifiable, Equatable, Sendable {/// next to one from another, so hits are never merged across kinds.@MainActorfinal class AppSearchService: ObservableObject {- static let shared = AppSearchService()+ static let shared = AppSearchService(+ prepareIndex: { try await SearchIndexCoordinator.shared.prepareForSearch() },+ retryPreparation: {+ TranscriptionHistoryStore.shared.retryLoadingIfNeeded()+ }+ )/// Hits fetched per indexed kind. The UI shows a few and offers the rest.static let limit = 50@@ -75,14 +80,48 @@ final class AppSearchService: ObservableObject {}@Published private(set) var groups: [AppSearchGroup] = []+ @Published private(set) var isSearching = false+ @Published private(set) var searchError: String?private let index: SearchIndex+ private let prepareIndex: @MainActor () async throws -> Void+ private let retryPreparation: @MainActor () -> Void+ private let performSearch: (@MainActor (String) async -> [AppSearchGroup])?+ private let readVocabulary: @Sendable () async throws -> [ParakeetVocabularyStore.VocabularyConfig.Term]private var task: Task<Void, Never>?private var token: ZeppelinCancellationToken?+ private var tokenID: UUID?private var chatAvailabilitySubscription: AnyCancellable?-- init(index: SearchIndex = .shared) {+ private var vocabularySubscription: AnyCancellable?+ private var vocabularyTerms: [ParakeetVocabularyStore.VocabularyConfig.Term] = []+ private var hasVocabularySnapshot = false+ private var vocabularyGeneration: UInt64 = 0+ private var stopped = false++ init(+ index: SearchIndex = .shared,+ prepareIndex: @escaping @MainActor () async throws -> Void = {},+ retryPreparation: @escaping @MainActor () -> Void = {},+ performSearch: (@MainActor (String) async -> [AppSearchGroup])? = nil,+ readVocabulary: @escaping @Sendable () async throws -> [ParakeetVocabularyStore.VocabularyConfig.Term] = {+ try await ParakeetVocabularyStore.readSearchTerms()+ },+ notificationCenter: NotificationCenter = .default+ ) {self.index = index+ self.prepareIndex = prepareIndex+ self.retryPreparation = retryPreparation+ self.performSearch = performSearch+ self.readVocabulary = readVocabulary+ self.vocabularySubscription = notificationCenter.publisher(for: .parakeetVocabularyDidChange)+ .receive(on: DispatchQueue.main)+ .sink { [weak self] _ in+ guard let self else { return }+ self.vocabularyGeneration &+= 1+ self.vocabularyTerms = []+ self.hasVocabularySnapshot = false+ self.refresh()+ }self.chatAvailabilitySubscription = ChatHistoryStore.shared.$sessions.map { Set($0.filter { !$0.isArchived }.map(\.id)) }.removeDuplicates()@@ -100,18 +139,43 @@ final class AppSearchService: ObservableObject {self.schedule()}+ /// Explicit retries may reload failed history. Ordinary keystrokes never do.+ func retry() {+ guard !self.stopped else { return }+ self.retryPreparation()+ self.schedule()+ }++ func stop() {+ self.stopped = true+ self.task?.cancel()+ self.task = nil+ if let token = self.token { Task { try? await token.cancel() } }+ self.token = nil+ self.tokenID = nil+ self.groups = []+ self.isSearching = false+ self.searchError = nil+ }+private func schedule() {+ guard !self.stopped else { return }self.task?.cancel()if let token = self.token {self.token = nil+ self.tokenID = nilTask { try? await token.cancel() }}let query = self.query.trimmingCharacters(in: .whitespacesAndNewlines)guard !query.isEmpty else {self.groups = []+ self.isSearching = false+ self.searchError = nilreturn}self.groups = []+ self.isSearching = true+ self.searchError = nilself.task = Task { [weak self] intry? await Task.sleep(for: Self.debounce)guard !Task.isCancelled, let self else { return }@@ -121,12 +185,39 @@ final class AppSearchService: ObservableObject {guard !Task.isCancelled else { return }let availableIDs = Set(ChatHistoryStore.shared.sessions.filter { !$0.isArchived }.map(\.id))self.groups = Self.removingUnavailableChats(from: groups, availableIDs: availableIDs)+ self.isSearching = false}}func search(_ query: String) async -> [AppSearchGroup] {+ guard !self.stopped, !query.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty else { return [] }+ do {+ try await self.prepareIndex()+ try Task.checkCancellation()+ } catch {+ if !Task.isCancelled, self.query.trimmingCharacters(in: .whitespacesAndNewlines) == query {+ self.searchError = error is SearchIndexCoordinator.PreparationError+ ? "Search is still getting ready. Try again shortly."+ : "Search is unavailable right now. Try again."+ }+ return []+ }+ guard !self.stopped else { return [] }+ if let performSearch = self.performSearch { return await performSearch(query) }let token = try? await ZeppelinCancellationToken.create()+ guard !Task.isCancelled, !self.stopped else {+ if let token { try? await token.cancel() }+ return []+ }+ let tokenID = UUID()self.token = token+ self.tokenID = tokenID+ defer {+ if self.tokenID == tokenID {+ self.token = nil+ self.tokenID = nil+ }+ }async let history = self.hits(.history, query, token)async let transcripts = self.hits(.transcripts, query, token)@@ -136,10 +227,12 @@ final class AppSearchService: ObservableObject {self.transcriptGroup(transcripts, query),self.chatGroup(chats, query),]+ guard !Task.isCancelled else { return [] }+ let vocabulary = await self.vocabularyGroup(query)let inMemory = [self.dictionaryGroup(query),self.promptGroup(query),- self.vocabularyGroup(query),+ vocabulary,self.punctuationGroup(query),self.settingsGroup(query),]@@ -191,7 +284,8 @@ final class AppSearchService: ObservableObject {}private func historyGroup(_ hits: [SearchIndex.Hit], _ query: String) -> AppSearchGroup {- let rows = Dictionary(TranscriptionHistoryStore.shared.entries.map { ($0.id, $0) }) { first, _ in first }+ let wanted = Set(hits.map(\.id))+ let rows = Dictionary(TranscriptionHistoryStore.shared.entries.lazy.filter { wanted.contains($0.id) }.map { ($0.id, $0) }) { first, _ in first }return AppSearchGroup(kind: .history, hits: Self.ranked(hits, rows: rows, date: \.timestamp) { entry inAppSearchHit(kind: .history,@@ -204,7 +298,8 @@ final class AppSearchService: ObservableObject {}private func transcriptGroup(_ hits: [SearchIndex.Hit], _ query: String) -> AppSearchGroup {- let rows = Dictionary(FileTranscriptionHistoryStore.shared.entries.map { ($0.id, $0) }) { first, _ in first }+ let wanted = Set(hits.map(\.id))+ let rows = Dictionary(FileTranscriptionHistoryStore.shared.entries.lazy.filter { wanted.contains($0.id) }.map { ($0.id, $0) }) { first, _ in first }return AppSearchGroup(kind: .transcripts, hits: Self.ranked(hits, rows: rows, date: \.timestamp) { entry inAppSearchHit(kind: .transcripts,@@ -217,9 +312,10 @@ final class AppSearchService: ObservableObject {}private func chatGroup(_ hits: [SearchIndex.Hit], _ query: String) -> AppSearchGroup {+ let wanted = Set(hits.map(\.id))let rows = Dictionary(ChatHistoryStore.shared.sessions.compactMap { session -> (UUID, ChatSession)? in- guard !session.isArchived, let id = UUID(uuidString: session.id) else { return nil }+ guard !session.isArchived, let id = UUID(uuidString: session.id), wanted.contains(id) else { return nil }return (id, session)}) { first, _ in first }@@ -275,8 +371,23 @@ final class AppSearchService: ObservableObject {return AppSearchGroup(kind: .prompts, hits: hits)}- private func vocabularyGroup(_ query: String) -> AppSearchGroup {- let terms = (try? ParakeetVocabularyStore.shared.loadUserBoostTerms()) ?? []+ private func vocabularyGroup(_ query: String) async -> AppSearchGroup {+ let generation = self.vocabularyGeneration+ let terms: [ParakeetVocabularyStore.VocabularyConfig.Term]+ if self.hasVocabularySnapshot {+ terms = self.vocabularyTerms+ } else {+ do {+ terms = try await self.readVocabulary()+ if generation == self.vocabularyGeneration {+ self.vocabularyTerms = terms+ self.hasVocabularySnapshot = true+ }+ } catch {+ // A transient read failure must remain retryable on the next query.+ terms = []+ }+ }let hits = terms.filter { Self.matches(query, [$0.text] + $0.aliases) }.map { term indiff --git a/Sources/Fluid/Services/CompactSpeechModelReleaseCatalog.swift b/Sources/Fluid/Services/CompactSpeechModelReleaseCatalog.swiftnew file mode 100644index 00000000..4d9db43f--- /dev/null+++ b/Sources/Fluid/Services/CompactSpeechModelReleaseCatalog.swift@@ -0,0 +1,467 @@+import Combine+import Darwin+import Foundation++/// UI/provider lookup reads immutable metadata; all feed and state IO happens off main.+@MainActor+final class CompactSpeechModelReleaseCatalog: ObservableObject {+ typealias Descriptor = ParakeetSpeechModelCatalog.Descriptor+ typealias Variant = ParakeetSpeechModelCatalog.Variant+ typealias Fetcher = @Sendable () async throws -> Data++ nonisolated struct Snapshot: Equatable, Sendable {+ let revision: UInt64+ let sequence: Int+ let descriptors: [Variant: Descriptor]+ let rejectedManifestHashes: Set<String>+ }++ private nonisolated struct StoredState: Codable, Sendable {+ let lastCheck: Date?+ let lastCheckSucceeded: Bool+ let rejectedManifestHashes: [String]+ }++ private nonisolated struct FeedCommit: Sendable {+ let payload: SpeechModelFeed.Payload+ let acceptedIncoming: Bool+ }++ private nonisolated enum CacheError: Error { case busy, invalidLock }++ static let shared = CompactSpeechModelReleaseCatalog()+ nonisolated static let manifestURL = CompactSpeechModelReleaseCatalog.fixedURL("https://models.fluidvoice.app/feed/v1/speech-models.json")+ nonisolated static let stagingURL = CompactSpeechModelReleaseCatalog.fixedURL("https://models.fluidvoice.app/feed/v1/speech-models-staging.json")+ nonisolated static let publicKeys = [+ "etCg9rPWJ81mB3XdJfKs2Y6QeuJjIIqCYfbYy40LRY4=",+ "Lf4aPkJzkEbu7nUj2Oh+ltoCePbPGXQMEMh+KfqtJvw=",+ ]+ nonisolated static let maximumManifestBytes = SpeechModelFeed.maximumEnvelopeBytes+ nonisolated static let supportedFormat = 1+ private nonisolated static let maximumRejectedReleases = 64+ @Published private(set) var snapshot = Snapshot(+ revision: 0,+ sequence: 0,+ descriptors: [.mini: ParakeetSpeechModelCatalog.mini, .pico: ParakeetSpeechModelCatalog.pico],+ rejectedManifestHashes: []+ )+ var revision: UInt64 { self.snapshot.revision }++ private let keys: [String]+ private let cacheURL: URL?+ private let stateURL: URL?+ private let fetch: Fetcher+ private let build: Int+ private let refreshInterval: TimeInterval+ private let retryInterval: TimeInterval+ private let now: @Sendable () -> Date+ private let staging: Bool+ private var loadedCache = false+ private var loadTask: Task<Void, Never>?+ private var lastCheck: Date?+ private var lastCheckSucceeded = false+ private var rejectedOrder: [String] = []+ private var refreshTask: Task<Void, Never>?+ private var stateWriteTask: Task<Void, Never>?+ private var pendingState: StoredState?++ init(+ publicKeys: [String] = CompactSpeechModelReleaseCatalog.publicKeys,+ cacheURL: URL? = CompactSpeechModelReleaseCatalog.defaultCacheURL(),+ build: Int = (Bundle.main.infoDictionary?["CFBundleVersion"] as? String).flatMap(Int.init) ?? 0,+ refreshInterval: TimeInterval = 24 * 60 * 60,+ retryInterval: TimeInterval = 60 * 60,+ now: @escaping @Sendable () -> Date = { Date() },+ fetch: Fetcher? = nil+ ) {+ self.keys = publicKeys+ self.cacheURL = cacheURL+ self.stateURL = cacheURL?.appendingPathExtension("state")+ self.build = build+ self.refreshInterval = refreshInterval+ self.retryInterval = retryInterval+ self.now = now+ self.staging = Self.usesStaging+ self.fetch = fetch ?? { try await Self.fetchManifest() }+ }++ func descriptor(for model: SettingsStore.SpeechModel) -> Descriptor? {+ switch model {+ case .fluidParakeetMini: self.descriptor(for: .mini)+ case .fluidParakeetPico: self.descriptor(for: .pico)+ default: nil+ }+ }++ func descriptor(for variant: Variant) -> Descriptor {+ self.snapshot.descriptors[variant] ?? ParakeetSpeechModelCatalog.descriptor(for: variant)+ }++ /// Event-driven checks join one worker. A failure never removes the last good feed.+ func refreshIfNeeded(force: Bool = false) async {+ if let refreshTask { await refreshTask.value; return }+ let task = Task { [weak self] in+ guard let self else { return }+ await self.loadCacheIfNeeded()+ let date = self.now()+ let interval = self.lastCheckSucceeded ? self.refreshInterval : self.retryInterval+ if !force, !self.staging, let lastCheck = self.lastCheck {+ let elapsed = date.timeIntervalSince(lastCheck)+ if elapsed >= 0, elapsed < interval {+ if self.pendingState != nil { await self.persistState() }+ self.refreshTask = nil+ return+ }+ }+ self.lastCheck = date+ do {+ let data = try await self.fetch()+ try Task.checkCancellation()+ if let cacheURL = self.cacheURL {+ let commit = try await Self.commitFeed(data, at: cacheURL, publicKeys: self.keys, lastSequence: self.snapshot.sequence)+ self.apply(commit.payload)+ self.lastCheckSucceeded = commit.acceptedIncoming+ } else {+ let payload = try await Self.verify(data, publicKeys: self.keys, lastSequence: self.snapshot.sequence)+ self.apply(payload)+ self.lastCheckSucceeded = true+ }+ } catch {+ self.lastCheckSucceeded = false+ }+ await self.persistState()+ self.refreshTask = nil+ }+ self.refreshTask = task+ await task.value+ }++ /// Only a staged model's load/sentence proof failure rejects a release; cancellation does not.+ func reject(manifestSHA256: String) async {+ guard Self.validHash(manifestSHA256) else { return }+ await self.loadCacheIfNeeded()+ if self.snapshot.rejectedManifestHashes.contains(manifestSHA256) {+ if self.pendingState != nil { await self.persistState() }+ return+ }+ self.rejectedOrder.append(manifestSHA256)+ if self.rejectedOrder.count > Self.maximumRejectedReleases {+ self.rejectedOrder.removeFirst(self.rejectedOrder.count - Self.maximumRejectedReleases)+ }+ self.snapshot = Snapshot(+ revision: self.snapshot.revision &+ 1,+ sequence: self.snapshot.sequence,+ descriptors: self.snapshot.descriptors,+ rejectedManifestHashes: Set(self.rejectedOrder)+ )+ await self.persistState()+ }++ private func loadCacheIfNeeded() async {+ if let loadTask { await loadTask.value; return }+ guard !self.loadedCache else { return }+ let task = Task { [weak self] in+ guard let self else { return }+ if let stateURL = self.stateURL,+ let bytes = await Self.readBoundedData(at: stateURL),+ let state = await Self.decodeState(bytes)+ {+ self.lastCheck = state.lastCheck+ self.lastCheckSucceeded = state.lastCheckSucceeded+ self.rejectedOrder = state.rejectedManifestHashes+ self.snapshot = Snapshot(+ revision: self.snapshot.revision &+ 1,+ sequence: self.snapshot.sequence,+ descriptors: self.snapshot.descriptors,+ rejectedManifestHashes: Set(self.rejectedOrder)+ )+ }+ if let cacheURL = self.cacheURL,+ let bytes = await Self.readBoundedData(at: cacheURL),+ let payload = try? await Self.verify(bytes, publicKeys: self.keys, lastSequence: 0)+ {+ self.apply(payload)+ } else if self.lastCheckSucceeded {+ // Missing/corrupt last-good metadata cannot suppress a recovery fetch for a day.+ self.lastCheck = nil+ self.lastCheckSucceeded = false+ }+ self.loadedCache = true+ self.loadTask = nil+ }+ self.loadTask = task+ await task.value+ }++ private func apply(_ payload: SpeechModelFeed.Payload) {+ let descriptors = Self.descriptors(in: payload, build: self.build)+ guard self.snapshot.sequence != payload.sequence || descriptors != self.snapshot.descriptors else { return }+ self.snapshot = Snapshot(+ revision: self.snapshot.revision &+ 1,+ sequence: payload.sequence,+ descriptors: descriptors,+ rejectedManifestHashes: self.snapshot.rejectedManifestHashes+ )+ }++ nonisolated static func descriptors(in payload: SpeechModelFeed.Payload, build: Int) -> [Variant: Descriptor] {+ var result: [Variant: Descriptor] = [:]+ for variant in [Variant.mini, .pico] {+ let builtIn = ParakeetSpeechModelCatalog.descriptor(for: variant)+ if let entry = SpeechModelFeed.entry(in: payload, model: variant.rawValue, platform: "macos", build: build, supportedFormat: self.supportedFormat) {+ result[variant] = builtIn.replacingArchive(url: entry.url, sha256: entry.sha256, byteCount: entry.bytes, manifestSHA256: entry.manifestSHA256)+ } else {+ result[variant] = builtIn+ }+ }+ return result+ }++ private func persistState() async {+ guard let stateURL = self.stateURL else { return }+ self.pendingState = StoredState(+ lastCheck: self.lastCheck,+ lastCheckSucceeded: self.lastCheckSucceeded,+ rejectedManifestHashes: self.rejectedOrder+ )+ if let stateWriteTask { await stateWriteTask.value; return }+ let task = Task { [weak self] in+ guard let self else { return }+ while let state = self.pendingState {+ self.pendingState = nil+ if let stored = await Self.writeState(state, at: stateURL) {+ // A competing process may have remembered another failed release.+ let merged = Self.mergedRejections(stored.rejectedManifestHashes, self.rejectedOrder)+ self.rejectedOrder = merged+ if Set(merged) != self.snapshot.rejectedManifestHashes {+ self.snapshot = Snapshot(+ revision: self.snapshot.revision &+ 1,+ sequence: self.snapshot.sequence,+ descriptors: self.snapshot.descriptors,+ rejectedManifestHashes: Set(merged)+ )+ }+ } else {+ // Keep one latest state for the next event; never spin on a busy/broken volume.+ if self.pendingState == nil { self.pendingState = state }+ break+ }+ }+ self.stateWriteTask = nil+ }+ self.stateWriteTask = task+ await task.value+ }++ private nonisolated static var usesStaging: Bool {+ #if DEBUG+ ProcessInfo.processInfo.arguments.contains("--fv-model-feed=staging")+ #else+ false+ #endif+ }++ private nonisolated static func defaultCacheURL() -> URL? {+ #if DEBUG+ let isDebug = true+ #else+ let isDebug = false+ #endif+ let folder = self.cacheFolderName(bundleIdentifier: Bundle.main.bundleIdentifier, isDebug: isDebug)+ return FileManager.default.urls(for: .applicationSupportDirectory, in: .userDomainMask).first?+ .appendingPathComponent(folder, isDirectory: true)+ .appendingPathComponent(self.usesStaging ? "speech-model-feed-staging.json" : "speech-model-feed.json")+ }++ nonisolated static func cacheFolderName(bundleIdentifier: String?, isDebug: Bool) -> String {+ guard isDebug else { return "FluidVoice" }+ let identifier = bundleIdentifier ?? "debug"+ let valid = !identifier.isEmpty && identifier != "." && identifier != ".."+ && identifier.utf8.allSatisfy { (48...57).contains($0) || (65...90).contains($0) || (97...122).contains($0) || $0 == 45 || $0 == 46 }+ return "FluidVoice/\(valid ? identifier : "debug")"+ }++ private nonisolated static func fixedURL(_ value: String) -> URL {+ guard let url = URL(string: value) else { preconditionFailure("Invalid speech model feed URL") }+ return url+ }++ private nonisolated static func validHash(_ value: String) -> Bool {+ value.utf8.count == 64 && value.utf8.allSatisfy { (48...57).contains($0) || (97...102).contains($0) }+ }++ @concurrent private static func verify(_ data: Data, publicKeys: [String], lastSequence: Int) async throws -> SpeechModelFeed.Payload {+ try SpeechModelFeed.verified(envelope: data, publicKeys: publicKeys, lastSequence: lastSequence)+ }++ private final nonisolated class NoRedirects: NSObject, URLSessionTaskDelegate {+ nonisolated func urlSession(+ _ session: URLSession,+ task: URLSessionTask,+ willPerformHTTPRedirection response: HTTPURLResponse,+ newRequest request: URLRequest,+ completionHandler: @escaping (URLRequest?) -> Void+ ) {+ completionHandler(nil)+ }+ }++ @concurrent private static func fetchManifest() async throws -> Data {+ let configuration = URLSessionConfiguration.ephemeral+ configuration.timeoutIntervalForRequest = 10+ configuration.timeoutIntervalForResource = 10+ let session = URLSession(configuration: configuration)+ defer { session.invalidateAndCancel() }+ var request = URLRequest(url: self.usesStaging ? self.stagingURL : self.manifestURL)+ request.timeoutInterval = 10+ request.cachePolicy = .reloadIgnoringLocalAndRemoteCacheData+ let (bytes, response) = try await session.bytes(for: request, delegate: NoRedirects())+ guard let http = response as? HTTPURLResponse, http.statusCode == 200,+ http.expectedContentLength <= Int64(self.maximumManifestBytes)+ else { throw URLError(.badServerResponse) }+ var data = Data()+ for try await byte in bytes {+ try Task.checkCancellation()+ guard data.count < self.maximumManifestBytes else { throw SpeechModelFeed.Rejection.tooLarge }+ data.append(byte)+ }+ return data+ }++ @concurrent private static func readBoundedData(at url: URL) async -> Data? {+ self.readData(at: url)+ }++ private nonisolated static func readData(at url: URL) -> Data? {+ guard let attributes = try? FileManager.default.attributesOfItem(atPath: url.path),+ attributes[.type] as? FileAttributeType == .typeRegular,+ let size = (attributes[.size] as? NSNumber)?.intValue, size > 0, size <= self.maximumManifestBytes,+ let input = try? FileHandle(forReadingFrom: url)+ else { return nil }+ defer { try? input.close() }+ guard let data = try? input.read(upToCount: self.maximumManifestBytes + 1), data.count <= self.maximumManifestBytes else { return nil }+ return data+ }++ @concurrent private static func decodeState(_ data: Data) async -> StoredState? {+ self.validatedState(data)+ }++ private nonisolated static func validatedState(_ data: Data) -> StoredState? {+ guard let state = try? JSONDecoder().decode(StoredState.self, from: data),+ state.rejectedManifestHashes.count <= self.maximumRejectedReleases,+ state.rejectedManifestHashes.allSatisfy(self.validHash),+ Set(state.rejectedManifestHashes).count == state.rejectedManifestHashes.count+ else { return nil }+ return state+ }++ private nonisolated static func writeData(_ data: Data, at url: URL) throws {+ guard data.count <= self.maximumManifestBytes else { throw SpeechModelFeed.Rejection.tooLarge }+ try FileManager.default.createDirectory(at: url.deletingLastPathComponent(), withIntermediateDirectories: true)+ try data.write(to: url, options: .atomic)+ }++ /// No network work is performed while locked. Contention exits immediately for a later retry.+ private nonisolated static func withCacheLock<T>(at cacheURL: URL, operation: () throws -> T) throws -> T {+ try Task.checkCancellation()+ try FileManager.default.createDirectory(at: cacheURL.deletingLastPathComponent(), withIntermediateDirectories: true)+ let lockURL = cacheURL.appendingPathExtension("lock")+ let descriptor = open(lockURL.path, O_RDWR | O_CREAT | O_NOFOLLOW | O_CLOEXEC | O_NONBLOCK, 0o600)+ guard descriptor >= 0 else { throw NSError(domain: NSPOSIXErrorDomain, code: Int(errno)) }+ defer { Darwin.close(descriptor) }+ var attributes = stat()+ guard fstat(descriptor, &attributes) == 0, attributes.st_mode & S_IFMT == S_IFREG else { throw CacheError.invalidLock }+ guard flock(descriptor, LOCK_EX | LOCK_NB) == 0 else { throw CacheError.busy }+ defer { flock(descriptor, LOCK_UN) }+ try Task.checkCancellation()+ return try operation()+ }++ @concurrent private static func commitFeed(_ data: Data, at url: URL, publicKeys: [String], lastSequence: Int) async throws -> FeedCommit {+ try self.withCacheLock(at: url) {+ let stored = self.readData(at: url).flatMap { try? SpeechModelFeed.verified(envelope: $0, publicKeys: publicKeys, lastSequence: 0) }+ let payload = try SpeechModelFeed.verified(envelope: data, publicKeys: publicKeys, lastSequence: 0)+ let floor = max(lastSequence, stored?.sequence ?? 0)+ if payload.sequence < floor {+ guard let stored, stored.sequence >= lastSequence else { throw SpeechModelFeed.Rejection.staleSequence }+ return FeedCommit(payload: stored, acceptedIncoming: false)+ }+ try Task.checkCancellation()+ try self.writeData(data, at: url)+ return FeedCommit(payload: payload, acceptedIncoming: true)+ }+ }++ private nonisolated static func mergedRejections(_ stored: [String], _ incoming: [String]) -> [String] {+ var result: [String] = []+ for hash in stored + incoming {+ result.removeAll { $0 == hash }+ result.append(hash)+ }+ return Array(result.suffix(self.maximumRejectedReleases))+ }++ @concurrent private static func writeState(_ state: StoredState, at url: URL) async -> StoredState? {+ for attempt in 0..<3 {+ do {+ return try self.mergeState(state, at: url)+ } catch CacheError.busy {+ guard attempt < 2, !Task.isCancelled else { return nil }+ do { try await Task.sleep(for: .milliseconds(20)) } catch { return nil }+ } catch {+ return nil+ }+ }+ return nil+ }++ private nonisolated static func mergeState(_ state: StoredState, at url: URL) throws -> StoredState {+ try self.withCacheLock(at: url.deletingPathExtension()) {+ let stored = self.readData(at: url).flatMap(self.validatedState)+ let freshness: StoredState+ if let storedDate = stored?.lastCheck,+ state.lastCheck == nil || storedDate > (state.lastCheck ?? .distantPast)+ {+ freshness = stored ?? state+ } else {+ freshness = state+ }+ let succeeded = stored?.lastCheck == state.lastCheck+ ? state.lastCheckSucceeded && (stored?.lastCheckSucceeded ?? true)+ : freshness.lastCheckSucceeded+ let merged = StoredState(+ lastCheck: freshness.lastCheck,+ lastCheckSucceeded: succeeded,+ rejectedManifestHashes: self.mergedRejections(stored?.rejectedManifestHashes ?? [], state.rejectedManifestHashes)+ )+ try Task.checkCancellation()+ try self.writeData(JSONEncoder().encode(merged), at: url)+ return merged+ }+ }+}++extension ParakeetSpeechModelCatalog.Descriptor {+ nonisolated func replacingArchive(url: URL?, sha256: String?, byteCount: Int64? = nil, manifestSHA256: String? = nil) -> Self {+ let bytes = byteCount ?? self.expectedDownloadBytes+ return Self(+ modelID: self.modelID,+ variant: self.variant,+ folderName: self.folderName,+ expectedDownloadBytes: bytes,+ archiveURL: url,+ archiveSHA256: sha256,+ requiredModelNames: self.requiredModelNames,+ vocabularyFile: self.vocabularyFile,+ displayName: self.displayName,+ humanReadableName: self.humanReadableName,+ languageSupport: self.languageSupport,+ supportedLanguageCodes: self.supportedLanguageCodes,+ downloadSize: String(format: "~%.1f MiB", Double(bytes) / 1_048_576),+ cardDescription: self.cardDescription,+ performanceRatings: self.performanceRatings,+ manifestSHA256: manifestSHA256+ )+ }+}diff --git a/Sources/Fluid/Services/DictionaryAudioLearningService.swift b/Sources/Fluid/Services/DictionaryAudioLearningService.swiftindex 34445481..50a66392 100644--- a/Sources/Fluid/Services/DictionaryAudioLearningService.swift+++ b/Sources/Fluid/Services/DictionaryAudioLearningService.swift@@ -150,20 +150,31 @@ actor OriginalAudioEmbeddingExtractor {@concurrent static func extract(_ evidence: DictionaryLearningAudioEvidence) async throws -> PronunciationEnrollmentCapture {try Task.checkCancellation()#if arch(arm64)- let version: AsrModelVersion- switch evidence.modelKey {- case "parakeet-v2": version = .v2- case "parakeet-v3": version = .v3- default: throw PronunciationDictionaryStoreError.inconsistentEnrollment+ guard let descriptor = ParakeetSpeechModelCatalog.descriptor(forInstalledPronunciationModelKey: evidence.modelKey) else {+ if ParakeetSpeechModelCatalog.isOutdatedCompactPronunciationModelKey(evidence.modelKey) {+ throw PronunciationDictionaryStoreError.outdatedModelRevision+ }+ throw PronunciationDictionaryStoreError.inconsistentEnrollment+ }+ let version = descriptor.asrModelVersion+ let directory = AsrModels.defaultCacheDirectory(for: version)+ guard descriptor.installationRevisionMatches(at: directory),+ descriptor.variant == .v2 || descriptor.variant == .v3 || descriptor.installedArchiveSHA256(at: directory) == descriptor.archiveSHA256+ else {+ throw PronunciationDictionaryStoreError.outdatedModelRevision}let models = try await AsrModels.loadLocalOnly(- from: AsrModels.defaultCacheDirectory(for: version),+ from: directory,version: version)try Task.checkCancellation()+ guard descriptor.installationRevisionMatches(at: directory) else {+ throw PronunciationDictionaryStoreError.outdatedModelRevision+ }+ try Task.checkCancellation()let manager = AsrManager(config: ASRConfig(tdtConfig: TdtConfig(blankId: version.blankId),- encoderHiddenSize: 1024+ encoderHiddenSize: version.encoderHiddenSize))do {try await manager.initialize(models: models)diff --git a/Sources/Fluid/Services/DictionaryMatchPlayground.swift b/Sources/Fluid/Services/DictionaryMatchPlayground.swiftindex 7c92e410..ceb7cdca 100644--- a/Sources/Fluid/Services/DictionaryMatchPlayground.swift+++ b/Sources/Fluid/Services/DictionaryMatchPlayground.swift@@ -70,6 +70,26 @@ actor DictionaryMatchPlayground {static let shared = DictionaryMatchPlayground()private var running = false+ /// Resolve before loading a model: an older checkpoint's vectors remain saved+ /// but cannot be replayed through a different encoder with the same dimensions.+ nonisolated static func targetProfile(+ from profiles: [PronunciationDictionaryProfile],+ target: String,+ compatibleModelKeys: Set<String> = Set(ParakeetSpeechModelCatalog.descriptors.map(\.pronunciationModelKey))+ ) throws -> PronunciationDictionaryProfile {+ let matching = profiles.filter { $0.label.caseInsensitiveCompare(target) == .orderedSame }+ if let current = matching.first(where: {+ compatibleModelKeys.contains($0.modelKey)+ && ParakeetSpeechModelCatalog.descriptor(forInstalledPronunciationModelKey: $0.modelKey) != nil+ }) {+ return current+ }+ if matching.contains(where: { ParakeetSpeechModelCatalog.isOutdatedCompactPronunciationModelKey($0.modelKey) }) {+ throw PronunciationDictionaryStoreError.outdatedModelRevision+ }+ throw DictionaryMatchPlaygroundError.unavailable("No saved Parakeet pronunciation recordings for “\(target)”. Train this word by voice first.")+ }+func analyze(recordingID: UUID, audioURL: URL, savedTranscript: String, target: String) async throws -> DictionaryMatchReport {let file = try AVAudioFile(forReading: audioURL)let duration = Double(file.length) / file.processingFormat.sampleRate@@ -99,11 +119,14 @@ actor DictionaryMatchPlayground {let duration = Double(samples.count) / 16_000#if arch(arm64)let allProfiles = await PronunciationDictionaryStore.shared.allProfiles()- guard let targetProfile = allProfiles.first(where: {- $0.label.caseInsensitiveCompare(target) == .orderedSame && ["parakeet-v2", "parakeet-v3"].contains($0.modelKey)- }) else {- throw DictionaryMatchPlaygroundError.unavailable("No saved Parakeet pronunciation recordings for “\(target)”. Train this word by voice first.")+ var compatibleModelKeys: Set<String> = ["parakeet-v2", "parakeet-v3"]+ for descriptor in [ParakeetSpeechModelCatalog.mini, ParakeetSpeechModelCatalog.pico] {+ let directory = AsrModels.defaultCacheDirectory(for: descriptor.asrModelVersion)+ if let hash = descriptor.installedArchiveSHA256(at: directory) {+ compatibleModelKeys.insert(descriptor.modelID + ":sha256:" + hash)+ }}+ let targetProfile = try Self.targetProfile(from: allProfiles, target: target, compatibleModelKeys: compatibleModelKeys)let matching = allProfiles.filter { $0.modelKey == targetProfile.modelKey }.sorted {let lhsTarget = $0.dictionaryEntryID == targetProfile.dictionaryEntryIDlet rhsTarget = $1.dictionaryEntryID == targetProfile.dictionaryEntryID@@ -112,8 +135,21 @@ actor DictionaryMatchPlayground {}let profiles = Array(matching.prefix(64))try Task.checkCancellation()- let version: AsrModelVersion = targetProfile.modelKey == "parakeet-v2" ? .v2 : .v3- let models = try await AsrModels.loadLocalOnly(from: AsrModels.defaultCacheDirectory(for: version), version: version)+ guard let descriptor = ParakeetSpeechModelCatalog.descriptor(forInstalledPronunciationModelKey: targetProfile.modelKey) else {+ throw DictionaryMatchPlaygroundError.unavailable("This pronunciation model is unavailable.")+ }+ let version = descriptor.asrModelVersion+ let directory = AsrModels.defaultCacheDirectory(for: version)+ guard descriptor.installationRevisionMatches(at: directory),+ descriptor.variant == .v2 || descriptor.variant == .v3 || descriptor.installedArchiveSHA256(at: directory) == descriptor.archiveSHA256+ else {+ throw PronunciationDictionaryStoreError.outdatedModelRevision+ }+ let models = try await AsrModels.loadLocalOnly(from: directory, version: version)+ try Task.checkCancellation()+ guard descriptor.installationRevisionMatches(at: directory) else {+ throw PronunciationDictionaryStoreError.outdatedModelRevision+ }let manager = AsrManager(config: ASRConfig(tdtConfig: TdtConfig(blankId: version.blankId), encoderHiddenSize: version.encoderHiddenSize))do {try await manager.initialize(models: models)@@ -148,7 +184,7 @@ actor DictionaryMatchPlayground {samples: [Float], manager: AsrManager, profiles: [PronunciationDictionaryProfile],targetProfile: PronunciationDictionaryProfile, context: ReplayContext) async throws -> DictionaryMatchReport {- let references = DictionaryPronunciationReferences.make(profiles: profiles)+ let references = DictionaryPronunciationReferences.make(profiles: profiles, compatibleModelKey: targetProfile.modelKey)let vectors = references.map(\.embedding)var rows = references.map { reference inDictionaryMatchReport.Candidate(diff --git a/Sources/Fluid/Services/DictionaryNegativeExamples.swift b/Sources/Fluid/Services/DictionaryNegativeExamples.swiftindex a254c59e..6f84b335 100644--- a/Sources/Fluid/Services/DictionaryNegativeExamples.swift+++ b/Sources/Fluid/Services/DictionaryNegativeExamples.swift@@ -94,7 +94,10 @@ actor DictionaryNegativeExampleStore {}func frames(entryID: UUID, profileKey: String, modelKey: String) -> [DictionaryMatchFrames] {- ((try? self.read()) ?? []).filter { $0.entryID == entryID && $0.profileKey == profileKey && $0.modelKey == modelKey }.map(\.frames)+ guard ParakeetSpeechModelCatalog.descriptor(forInstalledPronunciationModelKey: modelKey) != nil+ || !ParakeetSpeechModelCatalog.isOutdatedCompactPronunciationModelKey(modelKey)+ else { return [] }+ return ((try? self.read()) ?? []).filter { $0.entryID == entryID && $0.profileKey == profileKey && $0.modelKey == modelKey }.map(\.frames)}func save(_ correction: DictionaryNegativeCorrection, expectedRevision: UUID) throws {diff --git a/Sources/Fluid/Services/DictionaryPronunciationReferences.swift b/Sources/Fluid/Services/DictionaryPronunciationReferences.swiftindex 3dabeff6..c92395c9 100644--- a/Sources/Fluid/Services/DictionaryPronunciationReferences.swift+++ b/Sources/Fluid/Services/DictionaryPronunciationReferences.swift@@ -9,8 +9,13 @@ enum DictionaryPronunciationReferences {let embedding: PronunciationEmbedding}- static func make(profiles: [PronunciationDictionaryProfile], hiddenSize: Int? = nil) -> [Reference] {+ static func make(profiles: [PronunciationDictionaryProfile], hiddenSize: Int? = nil, compatibleModelKey: String? = nil) -> [Reference] {profiles.flatMap { profile -> [Reference] in+ let compatible = compatibleModelKey.map {+ profile.modelKey == $0 && ParakeetSpeechModelCatalog.descriptor(forInstalledPronunciationModelKey: $0) != nil+ } ?? !ParakeetSpeechModelCatalog.isOutdatedCompactPronunciationModelKey(profile.modelKey)+ guard compatible, profile.enrollments.allSatisfy({ $0.modelKey == profile.modelKey })+ else { return [] }guard hiddenSize == nil || profile.hiddenSize == hiddenSize else { return [] }if let calibration = profile.edgeCalibration {let frames = profile.enrollments.compactMap(\.edgeFrameCount)diff --git a/Sources/Fluid/Services/DictionaryTemporalEncoder.swift b/Sources/Fluid/Services/DictionaryTemporalEncoder.swiftindex 71b0e341..8c4c8a5b 100644--- a/Sources/Fluid/Services/DictionaryTemporalEncoder.swift+++ b/Sources/Fluid/Services/DictionaryTemporalEncoder.swift@@ -6,7 +6,7 @@ import Foundation/// Uses the provider's already-loaded models; never downloads or starts an ASR decoder.nonisolated enum DictionaryTemporalEncoder {@concurrent static func encode(_ input: [Float], models: AsrModels) async throws -> DictionaryMatchFrames {- guard !input.isEmpty, input.count <= 240_000, input.allSatisfy(\.isFinite), let encoder = models.encoder else {+ guard !input.isEmpty, input.count <= 240_000, input.allSatisfy(\.isFinite) else {throw PronunciationDictionaryStoreError.inconsistentEnrollment}try Task.checkCancellation()@@ -25,29 +25,30 @@ nonisolated enum DictionaryTemporalEncoder {let pre = try await models.preprocessor.prediction(from: provider, options: AsrModels.optimizedPredictionOptions())try Task.checkCancellation()var fields: [String: MLFeatureValue] = [:]- for key in encoder.modelDescription.inputDescriptionsByName.keys {+ for key in models.encoderInputFeatureNames {fields[key] = pre.featureValue(for: key) ?? provider.featureValue(for: key)}- let output = try await encoder.prediction(from: MLDictionaryFeatureProvider(dictionary: fields), options: AsrModels.optimizedPredictionOptions())+ let output = try await models.predictEncoder(from: MLDictionaryFeatureProvider(dictionary: fields), options: AsrModels.optimizedPredictionOptions())try Task.checkCancellation()guard let array = output.featureValue(for: "encoder")?.multiArrayValue,let encodedLength = output.featureValue(for: "encoder_length")?.multiArrayValue,array.dataType == .float32, array.shape.count == 3 else { throw PronunciationDictionaryStoreError.inconsistentEnrollment }let shape = array.shape.map(\.intValue), strides = array.strides.map(\.intValue)- let hiddenAxis = shape[1] == 1024 ? 1 : 2, timeAxis = hiddenAxis == 1 ? 2 : 1- guard shape[hiddenAxis] == 1024 else { throw PronunciationDictionaryStoreError.inconsistentEnrollment }+ let hiddenSize = models.version.encoderHiddenSize+ let hiddenAxis = shape[1] == hiddenSize ? 1 : 2, timeAxis = hiddenAxis == 1 ? 2 : 1+ guard shape[hiddenAxis] == hiddenSize else { throw PronunciationDictionaryStoreError.inconsistentEnrollment }let end = min(input.count, max(1, Int((Double(input.count) / 1280).rounded()) * 1280))let count = min(encodedLength[0].intValue, min(shape[timeAxis], (end + 1279) / 1280))guard (1...192).contains(count) else { throw PronunciationDictionaryStoreError.inconsistentEnrollment }let data = array.dataPointer.bindMemory(to: Float.self, capacity: array.count)var values: [Float] = []- values.reserveCapacity(count * 1024)+ values.reserveCapacity(count * hiddenSize)for frame in 0..<count {- for d in 0..<1024 {+ for d in 0..<hiddenSize {values.append(data[frame * strides[timeAxis] + d * strides[hiddenAxis]])}}- let frames = DictionaryMatchFrames(hiddenSize: 1024, values: values)+ let frames = DictionaryMatchFrames(hiddenSize: hiddenSize, values: values)guard frames.isValid else { throw PronunciationDictionaryStoreError.inconsistentEnrollment }return frames}diff --git a/Sources/Fluid/Services/ExternalCoreMLModelRegistry.swift b/Sources/Fluid/Services/ExternalCoreMLModelRegistry.swiftindex e2a1cbe1..38e1c8f4 100644--- a/Sources/Fluid/Services/ExternalCoreMLModelRegistry.swift+++ b/Sources/Fluid/Services/ExternalCoreMLModelRegistry.swift@@ -2,11 +2,11 @@ import CoreMLimport FluidAudioimport Foundation-enum ExternalCoreMLASRBackend {+nonisolated enum ExternalCoreMLASRBackend: Sendable {case cohereTranscribe}-struct ExternalCoreMLManifestIdentity: Decodable {+nonisolated struct ExternalCoreMLManifestIdentity: Decodable, Sendable {let modelID: Stringlet sampleRate: Intlet maxAudioSamples: Int@@ -22,7 +22,7 @@ struct ExternalCoreMLManifestIdentity: Decodable {}}-enum ExternalCoreMLArtifactsValidationError: LocalizedError {+nonisolated enum ExternalCoreMLArtifactsValidationError: LocalizedError {case missingEntries([String])case manifestMissing(URL)case manifestUnreadable(URL, Error)@@ -57,7 +57,7 @@ enum ExternalCoreMLArtifactsValidationError: LocalizedError {}}-struct ExternalCoreMLASRModelSpec {+nonisolated struct ExternalCoreMLASRModelSpec: Sendable {private static let bundleStampFileName = ".fluid_artifact_bundle_version"let backend: ExternalCoreMLASRBackend@@ -244,7 +244,7 @@ extension SettingsStore.SpeechModel {var supportsCustomVocabulary: Bool {switch self {- case .parakeetTDT, .parakeetTDTv2:+ case .parakeetTDT, .parakeetTDTv2, .fluidParakeetMini, .fluidParakeetPico:return truedefault:return falsediff --git a/Sources/Fluid/Services/FluidAudioProvider.swift b/Sources/Fluid/Services/FluidAudioProvider.swiftindex b3dc9be0..39eb8965 100644--- a/Sources/Fluid/Services/FluidAudioProvider.swift+++ b/Sources/Fluid/Services/FluidAudioProvider.swift@@ -1,5 +1,118 @@import Foundation+/// A bounded recording and fixed verdict shared by the staged installer and its tests.+/// This runs only for newly downloaded compact weights, never for a healthy installed copy.+nonisolated enum CompactSpeechModelRuntimeCheck {+ static let words = ["quick", "brown", "fox", "jumps", "over", "lazy", "dog", "near", "quiet"]+ static let maximumSamples = 240_000++ enum Failure: LocalizedError, Equatable {+ case missingRecording+ case invalidRecording+ case incorrectTranscript+ case timedOut++ var errorDescription: String? {+ switch self {+ case .missingRecording, .invalidRecording:+ "The app's voice model verification recording is unavailable. Your previous model was kept."+ case .incorrectTranscript:+ "The updated voice model failed its test sentence. Your previous model was kept."+ case .timedOut:+ "The updated voice model took too long to verify. Your previous model was kept."+ }+ }+ }++ static var recordingURL: URL? {+ #if SWIFT_PACKAGE+ Bundle.module.url(forResource: "speech-model-check", withExtension: "pcm")+ #else+ Bundle(for: FluidAudioProvider.self).url(forResource: "speech-model-check", withExtension: "pcm")+ #endif+ }++ static func samples() throws -> [Float] {+ guard let url = self.recordingURL else { throw Failure.missingRecording }+ let file = try FileHandle(forReadingFrom: url)+ defer { try? file.close() }+ // A damaged resource cannot allocate an unbounded audio buffer.+ let data = try file.read(upToCount: self.maximumSamples * 2 + 1) ?? Data()+ return try self.decode(data)+ }++ static func decode(_ data: Data) throws -> [Float] {+ guard data.count >= 32_000, data.count <= self.maximumSamples * 2,+ data.count.isMultiple(of: 2)+ else { throw Failure.invalidRecording }+ // Byte decoding also works for unaligned Data slices; no Int16 pointer assumptions.+ return data.withUnsafeBytes { bytes in+ stride(from: 0, to: bytes.count, by: 2).map { offset in+ let bits = UInt16(bytes[offset]) | (UInt16(bytes[offset + 1]) << 8)+ return Float(Int16(bitPattern: bits)) / 32_768+ }+ }+ }++ static func accepts(_ text: String) -> Bool {+ let heard = Set(text.lowercased().split(whereSeparator: { !$0.isLetter }).map(String.init))+ return self.words.filter(heard.contains).count * 2 >= self.words.count+ }++ /// Requests cancellation at the deadline, then joins the work before returning.+ /// Core ML's in-flight native prediction is cooperative, not forcibly preemptible.+ static func withDeadline(+ _ timeout: Duration = .seconds(240),+ operation: @escaping @Sendable () async throws -> Void+ ) async throws {+ try Task.checkCancellation()+ try await withThrowingTaskGroup(of: Void.self) { group in+ group.addTask { try await operation() }+ group.addTask {+ try await Task.sleep(for: timeout)+ throw Failure.timedOut+ }+ defer { group.cancelAll() }+ _ = try await group.next()+ }+ try Task.checkCancellation()+ }++ #if arch(arm64)+ /// Validate unpublished files. A missing app resource is not evidence that a release is bad.+ static func validateStagedWeights(+ at directory: URL,+ descriptor: ParakeetSpeechModelCatalog.Descriptor+ ) async throws {+ let samples = try self.samples()+ do {+ try await self.withDeadline {+ let stagedModels = try await AsrModels.loadLocalOnly(from: directory, version: descriptor.asrModelVersion)+ let manager = AsrManager(config: ASRConfig.default)+ do {+ try await manager.initialize(models: stagedModels)+ try Task.checkCancellation()+ // An isolated manager never receives custom vocabulary or dictionary boosting.+ let result = try await manager.transcribe(samples, source: .microphone)+ try Task.checkCancellation()+ guard self.accepts(result.text) else { throw Failure.incorrectTranscript }+ await manager.cleanup()+ } catch {+ await manager.cleanup()+ throw error+ }+ }+ } catch {+ if Task.isCancelled || error is CancellationError { throw CancellationError() }+ if let manifestSHA256 = descriptor.manifestSHA256 {+ await CompactSpeechModelReleaseCatalog.shared.reject(manifestSHA256: manifestSHA256)+ }+ throw error+ }+ }+ #endif+}+/// Rejection of a meeting ASR configuration outside the fixed supported policy.nonisolated enum MeetingProviderOptionsError: Error, Equatable {case unsupportedASRModel(String)@@ -153,6 +266,10 @@ final class FluidAudioProvider: TranscriptionProvider {private(set) var boostedVocabularyTermsCount: Int = 0private var boostedTermLookup: [String] = []private var pronunciationModelKey = ""+ #if DEBUG+ var modelCacheRootForTesting: URL?+ var pronunciationModelKeyForTesting: String { self.pronunciationModelKey }+ #endifprivate var edgeReferenceCache: [UUID: PronunciationEmbedding] = [:]private var incrementalSharedFeatures = falseprivate var incrementalSharedEvidence: [Int: [(Range<Int>, DictionaryAcousticEvidence)]] = [:]@@ -166,6 +283,7 @@ final class FluidAudioProvider: TranscriptionProvider {/// Used for downloading specific models without changing the active selection.let modelOverride: SettingsStore.SpeechModel?private let configureWordBoosting: Bool+ private let updateCompactWeights: Bool/// Opt-in pinned meeting options. When nil (legacy dictation), enhancement switches and/// the custom dictionary are still read live from `SettingsStore` at each call site.private let meetingOptions: MeetingProviderOptions?@@ -177,11 +295,13 @@ final class FluidAudioProvider: TranscriptionProvider {init(modelOverride: SettingsStore.SpeechModel? = nil,configureWordBoosting: Bool = true,+ updateCompactWeights: Bool = false,enhancementOptions: FluidAudioProviderEnhancementOptions? = nil,pronunciationStore: PronunciationDictionaryStore = .shared) {self.modelOverride = modelOverrideself.configureWordBoosting = configureWordBoosting+ self.updateCompactWeights = updateCompactWeightsself.meetingOptions = nilself.enhancementOptions = enhancementOptionsself.pronunciationStore = pronunciationStore@@ -195,6 +315,7 @@ final class FluidAudioProvider: TranscriptionProvider {let options = try MeetingProviderOptions.resolve(configuration)self.modelOverride = options.modelself.configureWordBoosting = false+ self.updateCompactWeights = falseself.meetingOptions = optionsself.enhancementOptions = nilself.pronunciationStore = .shared@@ -206,6 +327,12 @@ final class FluidAudioProvider: TranscriptionProvider {?? SettingsStore.shared.experimentalParakeetUnifiedFinalEnabled}+ private var resolvedSpeechModel: SettingsStore.SpeechModel {+ let selected = self.modelOverride ?? SettingsStore.shared.selectedSpeechModel+ // Preserve the established fallback for old Qwen selections.+ return selected == .qwen3Asr ? .parakeetTDT : selected+ }+private var explicitPronunciationMatchingEnabled: Bool {self.meetingOptions?.pronunciationMatchingEnabled?? self.enhancementOptions?.pronunciationMatchingEnabled@@ -295,27 +422,77 @@ final class FluidAudioProvider: TranscriptionProvider {try Task.checkCancellation()guard self.isReady == false else { return }- let selectedModel = self.modelOverride ?? SettingsStore.shared.selectedSpeechModel- let asrModelVersion: AsrModelVersion = selectedModel == .parakeetTDTv2 ? .v2 : .v3- let modelVersion = selectedModel == .parakeetTDTv2 ? "v2" : "v3"- self.pronunciationModelKey = "parakeet-\(modelVersion)"+ let selectedModel = self.resolvedSpeechModel+ if self.updateCompactWeights { await CompactSpeechModelReleaseCatalog.shared.refreshIfNeeded() }+ try Task.checkCancellation()+ guard var descriptor = CompactSpeechModelReleaseCatalog.shared.descriptor(for: selectedModel)+ ?? selectedModel.parakeetDescriptor+ else {+ throw NSError(domain: "FluidAudioProvider", code: -1, userInfo: [NSLocalizedDescriptionKey: "Choose a supported Parakeet model."])+ }+ let asrModelVersion = descriptor.asrModelVersion+ let modelVersion = descriptor.variant.rawValue+ #if DEBUG+ let cacheDirectory = self.modelCacheRootForTesting ?? AsrModels.defaultCacheDirectory().deletingLastPathComponent()+ #elselet cacheDirectory = AsrModels.defaultCacheDirectory().deletingLastPathComponent()- let modelCacheDirectory = AsrModels.defaultCacheDirectory(for: asrModelVersion)+ #endif+ let modelCacheDirectory = descriptor.cacheDirectory(in: cacheDirectory)DebugLogger.shared.info("FluidAudioProvider: Starting model preparation for \(selectedModel.displayName) [version=\(modelVersion)]",source: "FluidAudioProvider")DebugLogger.shared.debug("FluidAudioProvider: target cache directory=\(cacheDirectory.path)", source: "FluidAudioProvider")- try Task.checkCancellation()- if FileManager.default.fileExists(atPath: modelCacheDirectory.path), !self.modelsExistOnDisk() {- DebugLogger.shared.warning(- "FluidAudioProvider: removing incomplete \(modelVersion) cache before download",- source: "FluidAudioProvider"- )- try FileManager.default.removeItem(at: modelCacheDirectory)- }let progressRelay = ModelPreparationProgressRelay(progressHandler)progressRelay.report(.preparingDownload)+ if self.updateCompactWeights {+ guard descriptor.variant == .mini || descriptor.variant == .pico else {+ throw NSError(domain: "FluidAudioProvider", code: -1, userInfo: [NSLocalizedDescriptionKey: "Only Mini and Pico support weight updates."])+ }+ let release = descriptor+ _ = try await ParakeetArchiveDownloader.ensurePresent(+ descriptor: descriptor,+ in: cacheDirectory,+ progressHandler: { progressRelay.report($0) },+ replaceExisting: true,+ stageValidator: { directory in+ progressRelay.report(.loading)+ try await CompactSpeechModelRuntimeCheck.validateStagedWeights(at: directory, descriptor: release)+ }+ )+ // Publication is the commit point. A later cancellation cannot turn a+ // completed replacement into a failure or remove its validated files.+ return+ }+ let inspectionDescriptor = descriptor+ let inspection = Task.detached(priority: .userInitiated) { () throws -> String? in+ try Task.checkCancellation()+ if let installedHash = inspectionDescriptor.installedArchiveSHA256(at: modelCacheDirectory) {+ return installedHash+ }+ try Task.checkCancellation()+ if FileManager.default.fileExists(atPath: modelCacheDirectory.path),+ !inspectionDescriptor.artifactsAreComplete(at: modelCacheDirectory)+ {+ try FileManager.default.removeItem(at: modelCacheDirectory)+ }+ return nil+ }+ let installedHash = try await withTaskCancellationHandler {+ try await inspection.value+ } onCancel: {+ inspection.cancel()+ }+ try Task.checkCancellation()+ if installedHash == nil, descriptor.variant == .mini || descriptor.variant == .pico {+ // Keep an installed checkpoint usable without a network wait. Only a+ // first download needs the bounded signed-catalog freshness check.+ await CompactSpeechModelReleaseCatalog.shared.refreshIfNeeded()+ try Task.checkCancellation()+ descriptor = CompactSpeechModelReleaseCatalog.shared.descriptor(for: selectedModel) ?? descriptor+ }+ self.pronunciationModelKey = installedHash.map { descriptor.modelID + ":sha256:" + $0 }+ ?? descriptor.pronunciationModelKeylet fluidAudioProgressHandler: DownloadUtils.ProgressHandler = { progress inswitch progress.phase {case .listing:@@ -333,11 +510,38 @@ final class FluidAudioProvider: TranscriptionProvider {// Download and load modelslet models: AsrModelsdo {- models = try await AsrModels.downloadAndLoad(- version: asrModelVersion,- progressHandler: fluidAudioProgressHandler- )+ if descriptor.archiveURL != nil {+ if installedHash == nil {+ let release = descriptor+ let validator: ParakeetArchiveDownloader.StageValidator?+ if release.variant == .mini || release.variant == .pico {+ validator = { directory in+ progressRelay.report(.loading)+ try await CompactSpeechModelRuntimeCheck.validateStagedWeights(at: directory, descriptor: release)+ }+ } else {+ validator = nil+ }+ _ = try await ParakeetArchiveDownloader.ensurePresent(+ descriptor: release,+ in: cacheDirectory,+ progressHandler: { progressRelay.report($0) },+ stageValidator: validator+ )+ }+ try Task.checkCancellation()+ progressRelay.report(.loading)+ models = try await AsrModels.loadLocalOnly(from: modelCacheDirectory, version: asrModelVersion)+ } else {+ models = try await AsrModels.downloadAndLoad(+ version: asrModelVersion,+ progressHandler: fluidAudioProgressHandler+ )+ }} catch {+ // A canceled transfer can still leave files that require user cleanup.+ // Keep that repair path visible instead of reporting an ordinary cancel.+ if ParakeetArchiveDownloader.isCleanupFailure(error) { throw error }let nsError = error as NSErrorif Task.isCancelled|| error is CancellationError@@ -369,7 +573,7 @@ final class FluidAudioProvider: TranscriptionProvider {// Shares the same underlying MLModel objects (reference types) so memory overhead// is only the decoder state (~100KB).let finalManager: AsrManager- if self.configureWordBoosting {+ if self.configureWordBoosting, selectedModel.supportsCustomVocabulary {do {if let vocabBundle = try await ParakeetVocabularyStore.shared.loadTokenizedVocabularyBundle() {DebugLogger.shared.debug(@@ -870,7 +1074,7 @@ final class FluidAudioProvider: TranscriptionProvider {let generation = self.recordingGenerationlet profiles = Self.preparedEdgeProfiles(await self.pronunciationProfiles(), cache: self.edgeReferenceCache)try self.requireCurrentRecording(generation)- let references = DictionaryPronunciationReferences.make(profiles: profiles)+ let references = DictionaryPronunciationReferences.make(profiles: profiles, compatibleModelKey: self.pronunciationModelKey)let useSharedFeatures = DictionaryMatcherExperiment.sharedFeaturesEnabledlet pronunciationGeneration = DictionaryMatcherExperiment.generationlet refiner: PronunciationChunkRefiner?@@ -1005,7 +1209,7 @@ final class FluidAudioProvider: TranscriptionProvider {textMayBeCorrected)}- let references = DictionaryPronunciationReferences.make(profiles: profiles, hiddenSize: features.hiddenSize)+ let references = DictionaryPronunciationReferences.make(profiles: profiles, hiddenSize: features.hiddenSize, compatibleModelKey: self.pronunciationModelKey)let matches = PronunciationEmbeddingMatcher.allMatches(prototypes: references.map(\.embedding),in: features,@@ -1227,6 +1431,9 @@ final class FluidAudioProvider: TranscriptionProvider {private func temporalReferences(_ profile: PronunciationDictionaryProfile, key: String, models: AsrModels) async throws -> [DictionaryMatchFrames] {guard DictionaryMatcherExperiment.sharedFeaturesEnabled else { return [] }+ guard profile.modelKey == self.pronunciationModelKey,+ profile.enrollments.allSatisfy({ $0.modelKey == profile.modelKey })+ else { throw PronunciationDictionaryStoreError.outdatedModelRevision }if let cached = self.temporalReferenceCache[key] { return cached }guard profile.enrollments.count >= 3 else { return [] }// Reserve a worst-case three-reference slot before encoding. Stable admission avoids@@ -1463,8 +1670,10 @@ final class FluidAudioProvider: TranscriptionProvider {}func modelsExistOnDisk() -> Bool {- let selectedModel = self.modelOverride ?? SettingsStore.shared.selectedSpeechModel+ let selectedModel = self.resolvedSpeechModelswitch selectedModel {+ case .fluidParakeetMini, .fluidParakeetPico:+ return SpeechModelInstallationSnapshot.shared.isInstalled(modelID: selectedModel.id)case .parakeetTDT, .parakeetTDTv2:return selectedModel.isInstalleddefault:@@ -1472,8 +1681,32 @@ final class FluidAudioProvider: TranscriptionProvider {}}+ /// Preparation uses a fresh off-main check; synchronous consumers only read+ /// the event-refreshed installation snapshot for hosted compact models.+ func refreshModelsExistOnDiskAsync() async throws -> Bool {+ let model = self.resolvedSpeechModel+ guard let descriptor = model.parakeetDescriptor, descriptor.archiveURL != nil else {+ return self.modelsExistOnDisk()+ }+ let installed = try await SpeechModelInstallationSnapshot.scan([+ .init(modelID: model.id, kind: .parakeet(descriptor)),+ ])+ try Task.checkCancellation()+ return installed.contains(model.id)+ }++ var preservesInstalledCompactWeights: Bool {+ self.resolvedSpeechModel == .fluidParakeetMini || self.resolvedSpeechModel == .fluidParakeetPico+ }++ var shouldClearCacheAfterCancellation: Bool {+ // Hosted downloads own their unpublished temporary files. A later load+ // cancellation must retain the verified, atomically published model.+ self.resolvedSpeechModel.parakeetDescriptor?.archiveURL == nil+ }+func clearCache() async throws {- let selectedModel = self.modelOverride ?? SettingsStore.shared.selectedSpeechModel+ let selectedModel = self.resolvedSpeechModelself.automaticPronunciationProfiles = []self.didLoadAutomaticPronunciationProfiles = falseself.recordingGeneration = UUID()@@ -1493,8 +1726,15 @@ final class FluidAudioProvider: TranscriptionProvider {self.boostedVocabularyTermsCount = 0self.boostedTermLookup = []- let version: AsrModelVersion = selectedModel == .parakeetTDTv2 ? .v2 : .v3- let directory = AsrModels.defaultCacheDirectory(for: version)+ guard let descriptor = selectedModel.parakeetDescriptor else {+ throw NSError(domain: "FluidAudioProvider", code: -1, userInfo: [NSLocalizedDescriptionKey: "Choose a supported Parakeet model."])+ }+ #if DEBUG+ let directory = self.modelCacheRootForTesting.map { descriptor.cacheDirectory(in: $0) }+ ?? AsrModels.defaultCacheDirectory(for: descriptor.asrModelVersion)+ #else+ let directory = AsrModels.defaultCacheDirectory(for: descriptor.asrModelVersion)+ #endiftry await Task.detached(priority: .userInitiated) {if FileManager.default.fileExists(atPath: directory.path) {try FileManager.default.removeItem(at: directory)@@ -1565,9 +1805,12 @@ final class FluidAudioProvider: TranscriptionProvider {private(set) var isWordBoostingActive: Bool = falseprivate(set) var boostedVocabularyTermsCount: Int = 0+ var preservesInstalledCompactWeights: Bool { false }+init(modelOverride: SettingsStore.SpeechModel? = nil,configureWordBoosting: Bool = true,+ updateCompactWeights: Bool = false,enhancementOptions: FluidAudioProviderEnhancementOptions? = nil) {// Intel stub - parameters ignoreddiff --git a/Sources/Fluid/Services/GlobalHotkeyManager.swift b/Sources/Fluid/Services/GlobalHotkeyManager.swiftindex 5cece606..7a1a7965 100644--- a/Sources/Fluid/Services/GlobalHotkeyManager.swift+++ b/Sources/Fluid/Services/GlobalHotkeyManager.swift@@ -306,6 +306,7 @@ final class GlobalHotkeyManager: NSObject {private var isRewriteRecordingProvider: (() -> Bool)?private var isShortcutCaptureActiveProvider: (() -> Bool)?private var shortcutCaptureHandler: ((NSEvent) -> NSEvent?)?+ private let isSessionLockedProvider: () -> Boolprivate var cancelCallback: (() -> CancelHandlingResult)?private var pasteLastTranscriptionCallback: (() -> Void)?private var hotkeyMode: HotkeyActivationMode = SettingsStore.shared.hotkeyMode@@ -540,7 +541,8 @@ final class GlobalHotkeyManager: NSObject {isCommandRecordingProvider: (() -> Bool)? = nil,isRewriteRecordingProvider: (() -> Bool)? = nil,isShortcutCaptureActiveProvider: (() -> Bool)? = nil,- shortcutCaptureHandler: ((NSEvent) -> NSEvent?)? = nil+ shortcutCaptureHandler: ((NSEvent) -> NSEvent?)? = nil,+ isSessionLockedProvider: @escaping () -> Bool = { GlobalHotkeyManager.currentSessionIsLocked() }) {self.asrService = asrServiceself.primaryShortcuts = primaryShortcuts@@ -564,6 +566,7 @@ final class GlobalHotkeyManager: NSObject {self.isRewriteRecordingProvider = isRewriteRecordingProviderself.isShortcutCaptureActiveProvider = isShortcutCaptureActiveProviderself.shortcutCaptureHandler = shortcutCaptureHandler+ self.isSessionLockedProvider = isSessionLockedProvidersuper.init()self.initializeWithDelay()@@ -2352,7 +2355,7 @@ final class GlobalHotkeyManager: NSObject {}private func canTriggerRecordingAction(_ label: String) -> Bool {- guard !Self.currentSessionIsLocked() else {+ guard !self.isSessionLockedProvider() else {DebugLogger.shared.info("Ignoring \(label) - screen is locked", source: "GlobalHotkeyManager")return false}diff --git a/Sources/Fluid/Services/Meeting/MeetingAutoDetector.swift b/Sources/Fluid/Services/Meeting/MeetingAutoDetector.swiftindex d3400371..b76cb091 100644--- a/Sources/Fluid/Services/Meeting/MeetingAutoDetector.swift+++ b/Sources/Fluid/Services/Meeting/MeetingAutoDetector.swift@@ -108,6 +108,8 @@ final class MeetingAutoDetector {private let clock: any MeetingClockProvidingprivate let isNativeDetectionEnabled: () -> Boolprivate let isBrowserDetectionEnabled: () -> Bool+ private let rejectionLogger: (String) -> Void+ private var lastLoggedRejectionByPID: [Int32: String] = [:]private var records: [Int32: CandidateRecord] = [:] {didSet { self.publishAutomaticTarget() }@@ -139,7 +141,8 @@ final class MeetingAutoDetector {activityGate: any DetectionActivityGate,clock: any MeetingClockProviding,isNativeDetectionEnabled: @escaping () -> Bool,- isBrowserDetectionEnabled: @escaping () -> Bool+ isBrowserDetectionEnabled: @escaping () -> Bool,+ rejectionLogger: @escaping (String) -> Void = { DebugLogger.shared.log($0, source: "MeetingAutoDetector") }) {self.workspaceEvents = workspaceEventsself.micActivity = micActivity@@ -150,6 +153,7 @@ final class MeetingAutoDetector {self.clock = clockself.isNativeDetectionEnabled = isNativeDetectionEnabledself.isBrowserDetectionEnabled = isBrowserDetectionEnabled+ self.rejectionLogger = rejectionLogger}// MARK: - Lifecycle@@ -186,6 +190,7 @@ final class MeetingAutoDetector {self.titleEnrichmentInFlight.removeAll()self.titleEnrichmentGeneration.removeAll()self.removeTransientDisarmObservers()+ self.lastLoggedRejectionByPID.removeAll()}private func pollTick(runGeneration: UInt64) async {@@ -252,6 +257,7 @@ final class MeetingAutoDetector {DebugLogger.shared.log("app-activated bundle=\(event.bundleIdentifier)", source: "MeetingAutoDetector")case .terminated:self.records[event.processID] = nil+ self.lastLoggedRejectionByPID[event.processID] = nilself.lastBrowserPollAt[event.processID] = nilself.titleEnrichmentInFlight.remove(event.processID)self.titleEnrichmentGeneration[event.processID] = nil@@ -526,36 +532,36 @@ final class MeetingAutoDetector {return // a transient HAL failure is not an inactive edge, but cannot confirm anew}guard now.timeIntervalSince(audioEvidenceAt) <= Self.confirmDeadlineSeconds else {- self.logConfirmRejected("deadline", bundleIdentifier: record.bundleIdentifier)+ self.logConfirmRejected("deadline", record: record)return}guard abs(windowEvidenceAt.timeIntervalSince(audioEvidenceAt)) <= Self.coincidenceWindowSeconds else {- self.logConfirmRejected("coincidence", bundleIdentifier: record.bundleIdentifier)+ self.logConfirmRejected("coincidence", record: record)return}let frontmostPasses = audioEvidenceSource == .process ? record.lastFrontmostAt != nil : self.isFrontmostNearEdge(record, edge: audioEvidenceAt)guard frontmostPasses else {- self.logConfirmRejected("frontmost", bundleIdentifier: record.bundleIdentifier)+ self.logConfirmRejected("frontmost", record: record)return}let readiness = self.activityGate.preflightState()guard readiness != .busy else {- self.logConfirmRejected("busy", bundleIdentifier: record.bundleIdentifier)+ self.logConfirmRejected("busy", record: record)return}let episodeKey = "pid:\(pid)|\(evidenceKey)"if var existingEpisode = self.episodesByKey[episodeKey] {if !existingEpisode.duplicateEpisodeRejectionLogged {- self.logConfirmRejected("duplicate-episode", bundleIdentifier: record.bundleIdentifier)+ self.logConfirmRejected("duplicate-episode", record: record)existingEpisode.duplicateEpisodeRejectionLogged = trueself.episodesByKey[episodeKey] = existingEpisode}return}guard (self.dismissedBundleUntil[record.bundleIdentifier].map { $0 > now }) != true else {- self.logConfirmRejected("bundle-suppressed", bundleIdentifier: record.bundleIdentifier)+ self.logConfirmRejected("bundle-suppressed", record: record)return}@@ -569,6 +575,7 @@ final class MeetingAutoDetector {confirmedAt: now)self.episodesByKey[episodeKey] = episode+ self.lastLoggedRejectionByPID[pid] = nilDebugLogger.shared.log("preflight-state=\(Self.readinessToken(readiness)) bundle=\(record.bundleIdentifier)", source: "MeetingAutoDetector")guard readiness != .busy else {@@ -587,8 +594,12 @@ final class MeetingAutoDetector {))}- private func logConfirmRejected(_ reason: String, bundleIdentifier: String) {- DebugLogger.shared.log("confirm-rejected reason=\(reason) bundle=\(bundleIdentifier)", source: "MeetingAutoDetector")+ private func logConfirmRejected(_ reason: String, record: CandidateRecord) {+ // Diagnostics follow reason changes; prompt admission still runs on every event.+ // These slots share the candidate lifetime and never mutate source-selection state.+ guard self.lastLoggedRejectionByPID[record.pid] != reason else { return }+ self.lastLoggedRejectionByPID[record.pid] = reason+ self.rejectionLogger("confirm-rejected reason=\(reason) bundle=\(record.bundleIdentifier)")}private static func readinessToken(_ state: DetectionPreflightState) -> String {@@ -760,6 +771,7 @@ final class MeetingAutoDetector {episode.consumed ? nil : episode.id}self.records = [:]+ self.lastLoggedRejectionByPID.removeAll()self.titleEnrichmentInFlight.removeAll()self.titleEnrichmentGeneration.removeAll()self.lastMicReleaseAt = nildiff --git a/Sources/Fluid/Services/Meeting/MeetingSessionCoordinator.swift b/Sources/Fluid/Services/Meeting/MeetingSessionCoordinator.swiftindex e81cb98b..95c7243f 100644--- a/Sources/Fluid/Services/Meeting/MeetingSessionCoordinator.swift+++ b/Sources/Fluid/Services/Meeting/MeetingSessionCoordinator.swift@@ -144,7 +144,10 @@ final class MeetingSessionCoordinator: ObservableObject {willSet { if (newValue == nil) != (self.stopTask == nil) { self.objectWillChange.send() } }}- private var interruptionTask: Task<Void, Never>?+ private var interruptionTask: Task<Void, Never>? {+ willSet { if (newValue == nil) != (self.interruptionTask == nil) { self.objectWillChange.send() } }+ }+private var terminationTask: Task<Void, Never>?private var retryTask: Task<MeetingSession, Error>? {willSet { if (newValue == nil) != (self.retryTask == nil) { self.objectWillChange.send() } }@@ -190,6 +193,7 @@ final class MeetingSessionCoordinator: ObservableObject {private var correctionUndoStacks: [MeetingSessionID: [TranscriptCorrection]] = [:]private let validateRecordingModels: @MainActor () async throws -> Void+ private let processingLogger: @MainActor (String) -> Voidprivate static let correctionUndoStackCap = 50init(@@ -198,7 +202,8 @@ final class MeetingSessionCoordinator: ObservableObject {processing: any MeetingProcessingControlling,audioArbiter: any MeetingAudioActivityArbitrating,preferredMicrophoneUID: @escaping @MainActor () -> String? = { nil },- validateRecordingModels: @escaping @MainActor () async throws -> Void = {}+ validateRecordingModels: @escaping @MainActor () async throws -> Void = {},+ processingLogger: @escaping @MainActor (String) -> Void = { DebugLogger.shared.info($0, source: "MeetingSessionCoordinator") }) {self.store = storeself.persistence = MeetingSessionPersistenceQueue(store: store)@@ -207,6 +212,7 @@ final class MeetingSessionCoordinator: ObservableObject {self.audioArbiter = audioArbiterself.preferredMicrophoneUID = preferredMicrophoneUIDself.validateRecordingModels = validateRecordingModels+ self.processingLogger = processingLogger}var currentSession: MeetingSession? {@@ -1548,6 +1554,22 @@ final class MeetingSessionCoordinator: ObservableObject {}private func process(_ inputSession: MeetingSession, generation: UUID) async throws -> MeetingSession {+ let diagnosticStarted = ContinuousClock.now+ var diagnosticStage = MeetingProcessingStage.pending+ var diagnosticOutcome = "failed"+ var diagnosticFailure: MeetingSessionFailure?+ defer {+ let elapsed = diagnosticStarted.duration(to: .now).components+ let elapsedMs = elapsed.seconds * 1000 + elapsed.attoseconds / 1_000_000_000_000_000+ var line = "Meeting processing outcome=\(diagnosticOutcome) session=\(inputSession.id) stage=\(diagnosticStage.rawValue) elapsedMs=\(elapsedMs)"+ if let failure = diagnosticFailure {+ // One bounded line; never add meeting titles, transcripts or audio contents.+ let detail = String(failure.message.prefix(512)).replacingOccurrences(of: "\n", with: " ").replacingOccurrences(of: "\r", with: " ")+ let code = String(failure.code.prefix(128)).replacingOccurrences(of: "\n", with: " ").replacingOccurrences(of: "\r", with: " ")+ line += " errorCode=\(code) detail=\(detail)"+ }+ self.processingLogger(line)+ }#if DEBUGAudioTopologyDiagnostics.record(.phaseBegin, owner: .meetingCoordinator, queueRole: .mainControl, phase: .processing)var diagnosticsProcessingSucceeded = false@@ -1568,6 +1590,8 @@ final class MeetingSessionCoordinator: ObservableObject {session: session,sessionDirectory: sessionDirectory) { [weak self] stage in+ guard self?.operationGeneration == generation else { return }+ diagnosticStage = stageself?.updateProcessingStage(stage, generation: generation)}guard self.operationGeneration == generation,@@ -1664,6 +1688,8 @@ final class MeetingSessionCoordinator: ObservableObject {self.state = .completed(session.id)self.operationGeneration = nilawait self.releaseActivityLease()+ diagnosticOutcome = "completed"+ diagnosticStage = .completed// afterTranscription policy deletes here; sweep failures are logged, never affect this result.Task { @MainActor [weak self] in await self?.sweepExpiredAudio() }#if DEBUG@@ -1671,7 +1697,9 @@ final class MeetingSessionCoordinator: ObservableObject {#endifreturn session} catch {+ if error is CancellationError { diagnosticOutcome = "cancelled" }guard self.operationGeneration == generation else {+ diagnosticOutcome = "superseded"throw error}if error is CancellationError {@@ -1693,6 +1721,7 @@ final class MeetingSessionCoordinator: ObservableObject {throw error}let failure = Self.failure(from: error, domain: .processing, recoverable: true)+ diagnosticFailure = failure// A failed completed-session save must not durably publish a sidecar or overwrite the// last saved transcript under `.failed`. The verified new sidecar remains unreferenced// for retry/journal reconciliation.diff --git a/Sources/Fluid/Services/MenuBarManager.swift b/Sources/Fluid/Services/MenuBarManager.swiftindex ce3b4a12..edf18ed3 100644--- a/Sources/Fluid/Services/MenuBarManager.swift+++ b/Sources/Fluid/Services/MenuBarManager.swift@@ -1544,9 +1544,10 @@ final class MenuBarManager: NSObject, ObservableObject, NSMenuDelegate {}private func ensureUsableMainWindow(_ window: NSWindow) {+ guard !window.styleMask.contains(.fullScreen) else { return }// If the window is too small (e.g., height collapsed), reset to the default frame.let minSize = self.mainWindowMinimumSize- window.minSize = minSize+ if window.minSize != minSize { window.minSize = minSize }let frame = window.frameif frame.height < minSize.height || frame.width < minSize.width {diff --git a/Sources/Fluid/Services/NemotronProvider.swift b/Sources/Fluid/Services/NemotronProvider.swiftindex 86f6f09b..7c7ab75e 100644--- a/Sources/Fluid/Services/NemotronProvider.swift+++ b/Sources/Fluid/Services/NemotronProvider.swift@@ -38,7 +38,7 @@ final class NemotronProvider: TranscriptionProvider {private let repositoryOwner = "BarathwajAnandan"private let repositoryRevision = "main"- static let requiredFiles = [+ nonisolated static let requiredFiles = ["metadata.json","preprocessor.mlpackage","encoder.mlpackage",@@ -79,7 +79,7 @@ final class NemotronProvider: TranscriptionProvider {return Self.artifactsAreComplete(at: dir)}- static func artifactsAreComplete(at directory: URL) -> Bool {+ nonisolated static func artifactsAreComplete(at directory: URL) -> Bool {guard HuggingFaceModelDownloader.artifactsAreComplete(root: directory,items: self.requiredFiles.map {diff --git a/Sources/Fluid/Services/ParakeetSpeechModelBackend.swift b/Sources/Fluid/Services/ParakeetSpeechModelBackend.swiftnew file mode 100644index 00000000..8b7691b5--- /dev/null+++ b/Sources/Fluid/Services/ParakeetSpeechModelBackend.swift@@ -0,0 +1,17 @@+#if arch(arm64)+import FluidAudio+import Foundation++/// Converts immutable app metadata to the library contract without consulting settings.+nonisolated extension ParakeetSpeechModelCatalog.Descriptor {+ var asrModelVersion: AsrModelVersion {+ switch self.variant {+ case .v2: .v2+ case .v3: .v3+ case .mini: .fluidParakeetMini+ case .pico: .fluidParakeetPico+ }+ }+}++#endifdiff --git a/Sources/Fluid/Services/ParakeetSpeechModelCatalog.swift b/Sources/Fluid/Services/ParakeetSpeechModelCatalog.swiftnew file mode 100644index 00000000..52a4ae90--- /dev/null+++ b/Sources/Fluid/Services/ParakeetSpeechModelCatalog.swift@@ -0,0 +1,312 @@+import CryptoKit+import Foundation++/// Immutable metadata shared by model selection, cache ownership and ASR routing.+/// Resolving a descriptor performs no hardware, network or filesystem queries.+nonisolated enum ParakeetSpeechModelCatalog {+ enum Variant: String, CaseIterable, Sendable {+ case v2, v3, mini, pico+ }++ struct PerformanceRatings: Equatable, Sendable {+ let speedRating: Int+ let accuracyRating: Int+ let speedPercent: Double+ let accuracyPercent: Double+ }++ struct Descriptor: Equatable, Sendable {+ enum InstallationRevisionError: Error { case invalidChecksum }+ let modelID: String+ let variant: Variant+ let folderName: String+ let expectedDownloadBytes: Int64+ let archiveURL: URL?+ let archiveSHA256: String?+ let requiredModelNames: [String]+ let vocabularyFile: String+ let displayName: String+ let humanReadableName: String+ let languageSupport: String+ let supportedLanguageCodes: [String]+ let downloadSize: String+ let cardDescription: String+ let performanceRatings: PerformanceRatings?+ var manifestSHA256: String? = nil++ var isEnglishOnly: Bool { self.supportedLanguageCodes == ["en"] }++ var attribution: String {+ switch self.variant {+ case .v2, .v3: "NVIDIA Parakeet"+ case .mini, .pico: "NVIDIA Parakeet · Moondream Parakeet Ultra"+ }+ }++ var creditLine: String {+ switch self.variant {+ case .v2, .v3: "Built on NVIDIA Parakeet."+ case .mini, .pico: "Made by FluidVoice, built on NVIDIA Parakeet and Moondream’s Parakeet Ultra."+ }+ }++ /// Encoder vectors are compatible only with the checkpoint that produced them.+ /// Legacy v2/v3 keep their established persisted keys byte for byte.+ var pronunciationModelKey: String {+ switch self.variant {+ case .v2: "parakeet-v2"+ case .v3: "parakeet-v3"+ case .mini, .pico: "\(self.modelID):sha256:\(self.archiveSHA256 ?? "unavailable")"+ }+ }++ /// The caller supplies its existing cache root; appending a folder does no IO.+ func cacheDirectory(in modelsDirectory: URL) -> URL {+ modelsDirectory.appendingPathComponent(self.folderName, isDirectory: true)+ }++ /// Explicit filesystem validation for download/preparation work. This is+ /// separate from descriptor lookup; callers should run it off the main actor.+ func artifactsAreComplete(at directory: URL) -> Bool {+ guard self.installationRevisionMatches(at: directory) else { return false }+ guard HuggingFaceModelDownloader.artifactIsComplete(+ at: directory.appendingPathComponent(self.vocabularyFile), isDirectory: false+ ) else { return false }+ return self.requiredModelNames.allSatisfy { name in+ HuggingFaceModelDownloader.artifactIsComplete(+ at: directory.appendingPathComponent(name, isDirectory: true), isDirectory: true+ )+ }+ }++ /// Compact model folders are stable across releases; their exact installed+ /// archive revision must match before an existing cache may skip download.+ func installationRevisionMatches(at directory: URL) -> Bool {+ guard self.variant == .mini || self.variant == .pico else { return true }+ guard let hash = self.archiveSHA256, hash.count == 64,+ hash.utf8.allSatisfy({ (48...57).contains($0) || (97...102).contains($0) })+ else { return false }+ let marker = directory.appendingPathComponent(ParakeetSpeechModelCatalog.installationRevisionFileName)+ guard let attributes = try? FileManager.default.attributesOfItem(atPath: marker.path),+ attributes[.type] as? FileAttributeType == .typeRegular,+ (attributes[.size] as? NSNumber)?.intValue == 64,+ let input = try? FileHandle(forReadingFrom: marker)+ else { return false }+ defer { try? input.close() }+ return (try? input.read(upToCount: 65)) == Data(hash.utf8)+ }++ /// Explicit background-only disk inspection. Older compact checkpoints remain+ /// usable, but must not be mistaken for the currently advertised download.+ func installedArchiveSHA256(at directory: URL) -> String? {+ guard self.variant == .mini || self.variant == .pico,+ let rootAttributes = try? FileManager.default.attributesOfItem(atPath: directory.path),+ rootAttributes[.type] as? FileAttributeType == .typeDirectory+ else { return nil }+ let marker = directory.appendingPathComponent(ParakeetSpeechModelCatalog.installationRevisionFileName)+ guard let attributes = try? FileManager.default.attributesOfItem(atPath: marker.path),+ attributes[.type] as? FileAttributeType == .typeRegular,+ (attributes[.size] as? NSNumber)?.intValue == 64,+ let input = try? FileHandle(forReadingFrom: marker)+ else { return nil }+ defer { try? input.close() }+ guard let bytes = try? input.read(upToCount: 65), bytes.count == 64,+ bytes.allSatisfy({ (48...57).contains($0) || (97...102).contains($0) }),+ let hash = String(data: bytes, encoding: .utf8),+ HuggingFaceModelDownloader.artifactIsComplete(at: directory.appendingPathComponent(self.vocabularyFile), isDirectory: false),+ self.requiredModelNames.allSatisfy({ name in+ HuggingFaceModelDownloader.artifactIsComplete(at: directory.appendingPathComponent(name, isDirectory: true), isDirectory: true)+ })+ else { return nil }+ var enumerationFailed = false+ guard let enumerator = FileManager.default.enumerator(at: directory, includingPropertiesForKeys: nil, options: [], errorHandler: { _, _ in+ enumerationFailed = true+ return false+ }) else { return nil }+ var count = 0+ for case let item as URL in enumerator {+ if Task.isCancelled { return nil }+ count += 1+ guard count <= 50_000,+ let type = (try? FileManager.default.attributesOfItem(atPath: item.path))?[.type] as? FileAttributeType,+ type == .typeRegular || type == .typeDirectory+ else { return nil }+ }+ return enumerationFailed ? nil : hash+ }++ /// Small bounded identity read for installation snapshots, never UI rendering.+ /// Existing archive markers remain the pronunciation identity across migration.+ func installedManifestSHA256(at directory: URL) -> String? {+ guard self.variant == .mini || self.variant == .pico,+ (try? FileManager.default.attributesOfItem(atPath: directory.path))?[.type] as? FileAttributeType == .typeDirectory+ else { return nil }+ let file = directory.appendingPathComponent("manifest.json")+ guard let attributes = try? FileManager.default.attributesOfItem(atPath: file.path),+ attributes[.type] as? FileAttributeType == .typeRegular,+ let size = (attributes[.size] as? NSNumber)?.intValue,+ size > 0, size <= 1_048_576,+ let input = try? FileHandle(forReadingFrom: file)+ else { return nil }+ defer { try? input.close() }+ guard let data = try? input.read(upToCount: 1_048_577), data.count == size else { return nil }+ return SHA256.hash(data: data).map { String(format: "%02x", $0) }.joined()+ }++ /// Only the downloader calls this on its validated, unpublished stage.+ /// Exclusive creation rejects any marker supplied by the archive itself.+ func writeInstallationRevision(at directory: URL) throws {+ guard self.variant == .mini || self.variant == .pico else { return }+ guard let hash = self.archiveSHA256, hash.count == 64,+ hash.utf8.allSatisfy({ (48...57).contains($0) || (97...102).contains($0) })+ else { throw InstallationRevisionError.invalidChecksum }+ try Data(hash.utf8).write(+ to: directory.appendingPathComponent(ParakeetSpeechModelCatalog.installationRevisionFileName),+ options: .withoutOverwriting+ )+ }+ }++ static let installationRevisionFileName = ".fluidvoice-archive-sha256"+ static let standardModelNames = ["Preprocessor.mlmodelc", "Encoder.mlmodelc", "Decoder.mlmodelc", "JointDecision.mlmodelc"]+ static let splitModelNames = [+ "Preprocessor.mlmodelc", "Encoder-1.mlmodelc", "Encoder-2.mlmodelc",+ "Encoder-3.mlmodelc", "Encoder-4.mlmodelc", "Decoder.mlmodelc", "JointDecision.mlmodelc",+ ]++ static let v2 = Descriptor(+ modelID: "parakeet-tdt-v2",+ variant: .v2,+ folderName: "parakeet-tdt-0.6b-v2-coreml",+ expectedDownloadBytes: 464_421_712,+ archiveURL: nil,+ archiveSHA256: nil,+ requiredModelNames: ParakeetSpeechModelCatalog.standardModelNames,+ vocabularyFile: "parakeet_vocab.json",+ displayName: "Parakeet TDT v2 (English Only)",+ humanReadableName: "Blazing Fast - English",+ languageSupport: "English Only (Higher Accuracy)",+ supportedLanguageCodes: ["en"],+ downloadSize: "~442.9 MiB",+ cardDescription: "Optimized for English accuracy and fastest transcription.",+ performanceRatings: .init(speedRating: 5, accuracyRating: 5, speedPercent: 0.99, accuracyPercent: 0.96)+ )+ static let v3 = Descriptor(+ modelID: "parakeet-tdt",+ variant: .v3,+ folderName: "parakeet-tdt-0.6b-v3-coreml",+ expectedDownloadBytes: 483_288_717,+ archiveURL: nil,+ archiveSHA256: nil,+ requiredModelNames: ParakeetSpeechModelCatalog.standardModelNames,+ vocabularyFile: "parakeet_vocab.json",+ displayName: "Parakeet TDT v3 (Multilingual)",+ humanReadableName: "Blazing Fast - Multilingual",+ languageSupport: "25 Languages",+ supportedLanguageCodes: [+ "bg", "hr", "cs", "da", "nl", "en", "et", "fi", "fr", "de", "el", "hu", "it",+ "lv", "lt", "mt", "pl", "pt", "ro", "sk", "sl", "es", "sv", "ru", "uk",+ ],+ downloadSize: "~460.9 MiB",+ cardDescription: "Fast multilingual transcription. Supports Bulgarian, Croatian, Czech, Danish, " ++ "Dutch, English, Estonian, Finnish, French, German, Greek, Hungarian, Italian, " ++ "Latvian, Lithuanian, Maltese, Polish, Portuguese, Romanian, Russian, Slovak, " ++ "Slovenian, Spanish, Swedish, and Ukrainian.",+ performanceRatings: .init(speedRating: 5, accuracyRating: 5, speedPercent: 0.99, accuracyPercent: 0.92)+ )+ static let mini = Descriptor(+ modelID: "fluid-parakeet-mini",+ variant: .mini,+ folderName: "fluid-parakeet-mini-coreml",+ expectedDownloadBytes: 254_136_320,+ archiveURL: URL(string: "https://models.fluidvoice.app/parakeet/fluid-mini/1.1.1/fluid-parakeet-mini-coreml.tar"),+ archiveSHA256: "7f811554cc670ded812937502f928ae6aad946bbf6e4c2eecd6fcffbe76f4d16",+ requiredModelNames: ParakeetSpeechModelCatalog.splitModelNames,+ vocabularyFile: "parakeet_vocab.json",+ displayName: "Fluid Speech Mini",+ humanReadableName: "Fluid Speech Mini",+ languageSupport: "English Only",+ supportedLanguageCodes: ["en"],+ downloadSize: "~242.4 MiB",+ cardDescription: "Clear dictation in noisy places, at half the size of Blazing Fast. Runs on your Mac.",+ performanceRatings: .init(speedRating: 5, accuracyRating: 5, speedPercent: 0.99, accuracyPercent: 0.95),+ manifestSHA256: "32193c4cec7f5daf92fd617c424e7a157ea8dfcfa832a0db2cfcfa5cb9b674b8"+ )+ static let pico = Descriptor(+ modelID: "fluid-parakeet-pico",+ variant: .pico,+ folderName: "fluid-parakeet-pico-coreml",+ expectedDownloadBytes: 161_208_320,+ archiveURL: URL(string: "https://models.fluidvoice.app/parakeet/fluid-pico/1.1.1/fluid-parakeet-pico-coreml.tar"),+ archiveSHA256: "542f74f639438bf37ff134a7a75daddb50d301deb87696994e11ff272df21512",+ requiredModelNames: ParakeetSpeechModelCatalog.splitModelNames,+ vocabularyFile: "parakeet_vocab.json",+ displayName: "Fluid Speech Pico",+ humanReadableName: "Fluid Speech Pico",+ languageSupport: "English Only",+ supportedLanguageCodes: ["en"],+ downloadSize: "~153.7 MiB",+ cardDescription: "Our smallest model. Light enough for older Macs, and still clear in noisy places.",+ performanceRatings: .init(speedRating: 5, accuracyRating: 5, speedPercent: 1.0, accuracyPercent: 0.91),+ manifestSHA256: "a87ee649edc18aca6d30f251e75237f48c995448b865ffee35ab343ed3e66121"+ )++ static let descriptors = [ParakeetSpeechModelCatalog.v2, ParakeetSpeechModelCatalog.v3, ParakeetSpeechModelCatalog.mini, ParakeetSpeechModelCatalog.pico]++ static func descriptor(forModelID modelID: String) -> Descriptor? {+ self.descriptors.first { $0.modelID == modelID }+ }++ static func descriptor(forPronunciationModelKey modelKey: String) -> Descriptor? {+ self.descriptors.first { $0.pronunciationModelKey == modelKey }+ }++ /// A candidate for loading an existing checkpoint, never a download instruction.+ /// Callers must verify its hash against the installed marker before loadLocalOnly.+ static func descriptor(forInstalledPronunciationModelKey modelKey: String) -> Descriptor? {+ if modelKey == self.v2.pronunciationModelKey { return self.v2 }+ if modelKey == self.v3.pronunciationModelKey { return self.v3 }+ for source in [self.mini, self.pico] {+ let prefix = source.modelID + ":sha256:"+ guard modelKey.hasPrefix(prefix) else { continue }+ let hash = String(modelKey.dropFirst(prefix.count))+ guard hash.utf8.count == 64,+ hash.utf8.allSatisfy({ (48...57).contains($0) || (97...102).contains($0) })+ else { return nil }+ return Descriptor(+ modelID: source.modelID,+ variant: source.variant,+ folderName: source.folderName,+ expectedDownloadBytes: source.expectedDownloadBytes,+ archiveURL: nil,+ archiveSHA256: hash,+ requiredModelNames: source.requiredModelNames,+ vocabularyFile: source.vocabularyFile,+ displayName: source.displayName,+ humanReadableName: source.humanReadableName,+ languageSupport: source.languageSupport,+ supportedLanguageCodes: source.supportedLanguageCodes,+ downloadSize: source.downloadSize,+ cardDescription: source.cardDescription,+ performanceRatings: source.performanceRatings+ )+ }+ return nil+ }++ static func isOutdatedCompactPronunciationModelKey(_ modelKey: String) -> Bool {+ [self.mini, self.pico].contains { descriptor in+ (modelKey == descriptor.modelID || modelKey.hasPrefix(descriptor.modelID + ":sha256:"))+ && modelKey != descriptor.pronunciationModelKey+ }+ }++ static func descriptor(for variant: Variant) -> Descriptor {+ switch variant {+ case .v2: self.v2+ case .v3: self.v3+ case .mini: self.mini+ case .pico: self.pico+ }+ }+}diff --git a/Sources/Fluid/Services/ParakeetVocabularyStore.swift b/Sources/Fluid/Services/ParakeetVocabularyStore.swiftindex a45b490b..2e9082a5 100644--- a/Sources/Fluid/Services/ParakeetVocabularyStore.swift+++ b/Sources/Fluid/Services/ParakeetVocabularyStore.swift@@ -8,8 +8,8 @@ import FluidAudiofinal class ParakeetVocabularyStore {static let shared = ParakeetVocabularyStore()- struct VocabularyConfig: Codable, Sendable {- struct Term: Codable, Hashable, Sendable {+ nonisolated struct VocabularyConfig: Codable, Sendable {+ nonisolated struct Term: Codable, Hashable, Sendable {let text: Stringlet weight: Float?let aliases: [String]@@ -74,7 +74,7 @@ final class ParakeetVocabularyStore {}}- private enum Defaults {+ private nonisolated enum Defaults {// Balanced defaults to reduce over-biasing while still improving rare terms.static let alpha: Float = 2.8static let minCtcScore: Float = -2.2@@ -148,6 +148,19 @@ final class ParakeetVocabularyStore {return Self.normalizeUserTerms(parsed.terms, maxTerms: Defaults.maxTerms)}+ /// Search reads a bounded snapshot without creating files or blocking the UI.+ @concurrent nonisolated static func readSearchTerms() async throws -> [VocabularyConfig.Term] {+ guard let base = FileManager.default.urls(for: .applicationSupportDirectory, in: .userDomainMask).first else { return [] }+ let url = base.appendingPathComponent("FluidVoice/parakeet_custom_vocabulary.json")+ guard FileManager.default.fileExists(atPath: url.path) else { return [] }+ let handle = try FileHandle(forReadingFrom: url)+ defer { try? handle.close() }+ let limit = 2 * 1024 * 1024+ guard let data = try handle.read(upToCount: limit + 1), data.count <= limit else { return [] }+ let parsed = try JSONDecoder().decode(VocabularyConfig.self, from: data)+ return Self.normalizeUserTerms(parsed.terms, maxTerms: Defaults.maxTerms)+ }+/// Saves user-managed boost terms while keeping tuning backend-controlled.func saveUserBoostTerms(_ terms: [VocabularyConfig.Term]) throws {let normalizedTerms = Self.normalizeUserTerms(terms, maxTerms: Defaults.maxTerms)@@ -256,7 +269,7 @@ final class ParakeetVocabularyStore {}}- private static func normalizeUserTerms(_ terms: [VocabularyConfig.Term], maxTerms: Int) -> [VocabularyConfig.Term] {+ private nonisolated static func normalizeUserTerms(_ terms: [VocabularyConfig.Term], maxTerms: Int) -> [VocabularyConfig.Term] {var seen: Set<String> = []var normalized: [VocabularyConfig.Term] = []normalized.reserveCapacity(min(terms.count, maxTerms))diff --git a/Sources/Fluid/Services/PronunciationDictionaryStore.swift b/Sources/Fluid/Services/PronunciationDictionaryStore.swiftindex f9c53845..a7e0e458 100644--- a/Sources/Fluid/Services/PronunciationDictionaryStore.swift+++ b/Sources/Fluid/Services/PronunciationDictionaryStore.swift@@ -45,6 +45,7 @@ struct PronunciationDictionaryProfile: Codable, Equatable, Identifiable, Sendablenum PronunciationDictionaryStoreError: LocalizedError, Equatable {case inconsistentEnrollmentcase staleEvidence+ case outdatedModelRevisionvar errorDescription: String? {switch self {@@ -52,6 +53,8 @@ enum PronunciationDictionaryStoreError: LocalizedError, Equatable {"The dictionary entry changed before audio learning finished."case .inconsistentEnrollment:"Pronunciation samples must use the same model and embedding size."+ case .outdatedModelRevision:+ "These pronunciation recordings use an older voice model. Retrain this word by voice. Your custom words and text corrections remain saved."}}}diff --git a/Sources/Fluid/Services/SimpleUpdater.swift b/Sources/Fluid/Services/SimpleUpdater.swiftindex 89c16d2c..1a5d5e5e 100644--- a/Sources/Fluid/Services/SimpleUpdater.swift+++ b/Sources/Fluid/Services/SimpleUpdater.swift@@ -15,6 +15,8 @@ enum SimpleUpdateError: Error, LocalizedError {case unzipFailedcase notAnAppBundlecase codesignMismatch+ case backupFailed+ case installedAppChangedcase rollbackUnavailablecase rollbackRestoreFailed@@ -31,6 +33,8 @@ enum SimpleUpdateError: Error, LocalizedError {case .unzipFailed: return "Failed to extract the update archive."case .notAnAppBundle: return "Extracted content does not contain an app bundle."case .codesignMismatch: return "Downloaded app’s code signature does not match current app."+ case .backupFailed: return "The current app could not be backed up. Nothing was replaced."+ case .installedAppChanged: return "The installed app changed. Restart FluidVoice before trying the update again."case .rollbackUnavailable: return "No rollback backup is available."case .rollbackRestoreFailed: return "Failed to restore a previous version."}@@ -214,12 +218,12 @@ final class SimpleUpdater: ObservableObject {throw SimpleUpdateError.rollbackUnavailable}- self.createRollbackBackup(beforeRollback: true)-do {- try self.performSwapAndRelaunch(+ try await self.performSwapAndRelaunch(installedAppURL: Bundle.main.bundleURL,- downloadedAppURL: rollbackBundleURL+ downloadedAppURL: rollbackBundleURL,+ expectedVersion: nil,+ isRollback: true)DebugLogger.shared.info("SimpleUpdater: Rolled back to \(rollbackBundleURL.lastPathComponent)",@@ -291,7 +295,7 @@ final class SimpleUpdater: ObservableObject {// Allowed Apple Developer Team IDs for code-sign validation// Restrict update transitions to FluidVoice's approved signing teams.- private let allowedTeamIDs: Set<String> = [+ private nonisolated static let allowedTeamIDs: Set<String> = ["V4J43B279J","537RRRT57V",]@@ -646,6 +650,9 @@ final class SimpleUpdater: ObservableObject {appropriateFor: Bundle.main.bundleURL,create: true)+ defer {+ Task.detached(priority: .utility) { try? FileManager.default.removeItem(at: tempDir) }+ }let downloadURL = tempDir.appendingPathComponent(asset.browser_download_url.lastPathComponent)do {@@ -667,52 +674,12 @@ final class SimpleUpdater: ObservableObject {throw SimpleUpdateError.notAnAppBundle}- // Validate code signing identity matches (skip in DEBUG for easier local testing)- #if DEBUG- // In Debug builds the local app is typically signed with a development cert, while- // releases are signed with Developer ID. Skip strict check to enable testing.- _ = currentBundle // keep reference used in Release path- #else- let curID = try await codeSigningIdentity(for: currentBundle.bundleURL)- let newID = try await codeSigningIdentity(for: extractedBundleURL)-- func teamID(from identity: String) -> String? {- // Handle TeamIdentifier= format first- if identity.hasPrefix("TeamIdentifier=") {- return String(identity.dropFirst("TeamIdentifier=".count))- }-- // Handle Authority= format (extract team ID from parentheses)- guard let l = identity.lastIndex(of: "("), let r = identity.lastIndex(of: ")"), l < r else { return nil }- let inside = identity[identity.index(after: l)..<r]- return String(inside)- }-- // Allow update if:- // - full identity matches OR- // - Team IDs match OR- // - both current and new Team IDs are in the allowedTeamIDs set- // This enables dev→prod updates across your two known Team IDs.- let sameIdentity = curID == newID- let curTeam = teamID(from: curID)- let newTeam = teamID(from: newID)- let sameTeam = (curTeam != nil && curTeam == newTeam)- let bothAllowed: Bool = {- guard let ct = curTeam, let nt = newTeam else { return false }- return self.allowedTeamIDs.contains(ct) && self.allowedTeamIDs.contains(nt)- }()-- guard sameIdentity || sameTeam || bothAllowed else {- DebugLogger.shared.error("SimpleUpdater: Code-sign mismatch. Current=\(curID) New=\(newID)", source: "SimpleUpdater")- DebugLogger.shared.error("SimpleUpdater: Current Team=\(curTeam ?? "none") New Team=\(newTeam ?? "none")", source: "SimpleUpdater")- throw SimpleUpdateError.codesignMismatch- }- #endif-- self.createRollbackBackup(beforeRollback: false)-- // Replace and relaunch- try self.performSwapAndRelaunch(installedAppURL: currentBundle.bundleURL, downloadedAppURL: extractedBundleURL)+ try await self.performSwapAndRelaunch(+ installedAppURL: currentBundle.bundleURL,+ downloadedAppURL: extractedBundleURL,+ expectedVersion: rawVersion,+ isRollback: false+ )shouldKeepOperationActive = true}@@ -913,64 +880,39 @@ final class SimpleUpdater: ObservableObject {.replacingOccurrences(of: " ", with: "_")}- private func createRollbackBackup(beforeRollback: Bool) {- let currentAppVersion = self.currentAppVersion- let appURL = Bundle.main.bundleURL- let backupRoot = self.rollbackRootDirectory()-- do {- try self.fileManager.createDirectory(- at: backupRoot,- withIntermediateDirectories: true- )- } catch {- DebugLogger.shared.warning("SimpleUpdater: Failed to create rollback backup folder: \(error.localizedDescription)", source: "SimpleUpdater")- return- }-- let timestamp = Int(Date().timeIntervalSince1970)- let safeVersion = self.sanitizeVersion(currentAppVersion)- let backupName = beforeRollback- ? "\(self.installedAppName)-\(safeVersion)-rollback-\(timestamp).app"- : "\(self.installedAppName)-\(safeVersion)-\(timestamp).app"- let backupURL = backupRoot.appendingPathComponent(backupName)-- do {- try self.fileManager.copyItem(at: appURL, to: backupURL)- try? self.fileManager.setAttributes(- [.modificationDate: Date()],- ofItemAtPath: backupURL.path- )- self.pruneRollbackBackups()- DebugLogger.shared.info(- "SimpleUpdater: Created rollback backup at \(backupURL.path)",- source: "SimpleUpdater"- )- } catch {- DebugLogger.shared.warning(- "SimpleUpdater: Failed to create rollback backup: \(error.localizedDescription)",- source: "SimpleUpdater"- )- }- }-- private func pruneRollbackBackups() {- let backups = self.availableRollbackBackups()- guard backups.count > self.maxRollbackBackups else { return }-- for oldBackup in backups.dropFirst(self.maxRollbackBackups) {- do {- try self.fileManager.removeItem(at: oldBackup)- } catch {- DebugLogger.shared.warning(- "SimpleUpdater: Failed to remove old rollback backup \(oldBackup.lastPathComponent): \(error.localizedDescription)",- source: "SimpleUpdater"- )+ private func pruneRollbackBackups(preserving protectedURLs: Set<URL>) async {+ let root = self.rollbackRootDirectory()+ let limit = self.maxRollbackBackups+ let warnings = await Task.detached(priority: .utility) {+ let manager = FileManager.default+ guard let urls = try? manager.contentsOfDirectory(+ at: root,+ includingPropertiesForKeys: [.contentModificationDateKey],+ options: [.skipsHiddenFiles]+ ) else { return [String]() }+ let backups = Self.sortedRollbackBackups(urls.filter { $0.pathExtension == "app" }) {+ (try? $0.resourceValues(forKeys: [.contentModificationDateKey]))?.contentModificationDate+ }+ var retained = Set(backups.filter { protectedURLs.contains($0) })+ for backup in backups where retained.count < limit {+ retained.insert(backup)+ }+ var failures = [String]()+ for backup in backups where !retained.contains(backup) {+ do {+ try manager.removeItem(at: backup)+ } catch {+ failures.append(error.localizedDescription)+ }}+ return failures+ }.value+ for warning in warnings {+ DebugLogger.shared.warning("SimpleUpdater: Rollback cleanup failed: \(warning)", source: "SimpleUpdater")}}- static func sortedRollbackBackups(+ nonisolated static func sortedRollbackBackups(_ urls: [URL],modificationDate: (URL) -> Date?) -> [URL] {@@ -993,7 +935,7 @@ final class SimpleUpdater: ObservableObject {return version != currentVersion}- private static func rollbackBackupCreationDate(+ private nonisolated static func rollbackBackupCreationDate(from url: URL,fallbackModificationDate: Date?) -> Date? {@@ -1004,7 +946,7 @@ final class SimpleUpdater: ObservableObject {return fallbackModificationDate}- private static func rollbackBackupTimestamp(from url: URL) -> TimeInterval? {+ private nonisolated static func rollbackBackupTimestamp(from url: URL) -> TimeInterval? {let name = url.deletingPathExtension().lastPathComponentguard let suffix = name.split(separator: "-").last,let timestamp = TimeInterval(suffix)@@ -1090,110 +1032,184 @@ final class SimpleUpdater: ObservableObject {}}- private func codeSigningIdentity(for bundleURL: URL) async throws -> String {- let proc = Process()- proc.launchPath = "/usr/bin/codesign"- proc.arguments = ["-dvvv", bundleURL.path]- let pipe = Pipe()- proc.standardError = pipe-- return try await withCheckedThrowingContinuation { cont in- proc.terminationHandler = { _ in- let data = pipe.fileHandleForReading.readDataToEndOfFile()- let s = String(data: data, encoding: .utf8) ?? ""+ nonisolated struct PreparedInstallation: Sendable {+ let replacement: UpdateAppReplacement+ let backupURL: URL+ }- // First try to get TeamIdentifier (most reliable)- if let teamLine = s.split(separator: "\n").first(where: { $0.hasPrefix("TeamIdentifier=") }) {- cont.resume(returning: String(teamLine))- } else {- // Fallback to Authority line- let line = s.split(separator: "\n").first(where: { $0.hasPrefix("Authority=") })- cont.resume(returning: line.map(String.init) ?? "")+ /// Runs under the replacement's process-shared lock on a background task.+ nonisolated static func prepareValidatedInstallation(+ installedAppURL: URL,+ downloadedAppURL: URL,+ installedExpectation: UpdateBundleValidator.Expectation,+ expectedVersion: String?,+ backupURL: URL,+ isRollback: Bool+ ) throws -> PreparedInstallation {+ let teams = Self.allowedTeamIDs+ guard isRollback || expectedVersion != nil, installedExpectation.version != nil, installedExpectation.build != nil+ else { throw UpdateBundleValidator.ValidationError.invalidExpectation }+ try Task.checkCancellation()+ let replacement = try UpdateAppReplacement.prepare(+ installedAppURL: installedAppURL,+ replacementAppURL: downloadedAppURL,+ validateInstalledApp: { url in+ do {+ _ = try UpdateBundleValidator.validate(+ at: url,+ expectation: installedExpectation,+ policy: .installedApp(allowedTeamIDs: teams)+ )+ } catch UpdateBundleValidator.ValidationError.versionMismatch {+ throw SimpleUpdateError.installedAppChanged+ } catch UpdateBundleValidator.ValidationError.buildMismatch {+ throw SimpleUpdateError.installedAppChanged}}- do { try proc.run() } catch { cont.resume(throwing: error) }- }- }-- private func performSwapAndRelaunch(installedAppURL: URL, downloadedAppURL: URL) throws {- // Handle app name changes: if the downloaded app has a different name,- // we need to replace the old app and use the new name- let installedAppName = installedAppURL.lastPathComponent- let downloadedAppName = downloadedAppURL.lastPathComponent-- DebugLogger.shared.info("SimpleUpdater: Installing app - Current: \(installedAppName), New: \(downloadedAppName)", source: "SimpleUpdater")-- let finalAppURL: URL- if installedAppName != downloadedAppName {- // App name changed - use the new name- finalAppURL = installedAppURL.deletingLastPathComponent().appendingPathComponent(downloadedAppName)- DebugLogger.shared.info("SimpleUpdater: App name changed, installing to: \(finalAppURL.path)", source: "SimpleUpdater")-- // Safety check: ensure we don't overwrite an existing app with the new name- if FileManager.default.fileExists(atPath: finalAppURL.path) {- DebugLogger.shared.info("SimpleUpdater: Removing existing app at new location: \(finalAppURL.path)", source: "SimpleUpdater")- try FileManager.default.removeItem(at: finalAppURL)+ )+ var backupCreated = false+ do {+ try Task.checkCancellation()+ _ = try UpdateBundleValidator.validate(+ at: replacement.stagedAppURL,+ expectation: .init(bundleIdentifier: installedExpectation.bundleIdentifier, version: expectedVersion),+ policy: isRollback ? .installedApp(allowedTeamIDs: teams) : .developerID(allowedTeamIDs: teams)+ )+ do {+ try UpdateRollbackBackup.create(installedAppURL: installedAppURL, backupURL: backupURL) { url in+ _ = try UpdateBundleValidator.validate(+ at: url,+ expectation: installedExpectation,+ policy: .installedApp(allowedTeamIDs: teams)+ )+ }+ backupCreated = true+ } catch let failure as UpdateRollbackBackup.Failure where failure.retainedDirectoryURL != nil {+ throw failure+ } catch {+ throw SimpleUpdateError.backupFailed}-- // Remove old app if it exists- if FileManager.default.fileExists(atPath: installedAppURL.path) {- DebugLogger.shared.info("SimpleUpdater: Removing old app: \(installedAppURL.path)", source: "SimpleUpdater")- try FileManager.default.removeItem(at: installedAppURL)+ try Task.checkCancellation()+ try replacement.commit()+ return PreparedInstallation(replacement: replacement, backupURL: backupURL)+ } catch {+ let originalError = error+ // A failed atomic exchange leaves the installed app untouched. The owned+ // duplicate backup is unnecessary until the exchange succeeds.+ var backupCleanupFailure: Error?+ if backupCreated {+ do {+ try FileManager.default.removeItem(at: backupURL)+ } catch {+ backupCleanupFailure = UpdateAppReplacement.Failure(+ operation: .cleanup, recoveryDirectoryURL: backupURL, underlyingError: error+ )+ }}-- // Move new app to Applications with new name- try FileManager.default.moveItem(at: downloadedAppURL, to: finalAppURL)- DebugLogger.shared.info("SimpleUpdater: Successfully installed new app at: \(finalAppURL.path)", source: "SimpleUpdater")- } else {- // Same name - normal replacement- DebugLogger.shared.info("SimpleUpdater: Same app name, performing normal replacement", source: "SimpleUpdater")- if FileManager.default.fileExists(atPath: installedAppURL.path) {- try FileManager.default.removeItem(at: installedAppURL)+ do {+ try replacement.discardPrepared()+ } catch {+ throw error}- try FileManager.default.moveItem(at: downloadedAppURL, to: installedAppURL)- finalAppURL = installedAppURL+ if let backupCleanupFailure { throw backupCleanupFailure }+ throw originalError+ }+ }++ private func performSwapAndRelaunch(+ installedAppURL: URL,+ downloadedAppURL: URL,+ expectedVersion: String?,+ isRollback: Bool+ ) async throws {+ guard let identifier = Bundle.main.bundleIdentifier,+ let build = Bundle.main.infoDictionary?["CFBundleVersion"] as? String+ else { throw SimpleUpdateError.notAnAppBundle }+ let version = self.currentAppVersion+ let name = self.installedAppName+ let safeVersion = self.sanitizeVersion(version)+ let suffix = "\(isRollback ? "rollback-" : "")\(UUID().uuidString)-\(Int(Date().timeIntervalSince1970))"+ let backupURL = self.rollbackRootDirectory().appendingPathComponent("\(name)-\(safeVersion)-\(suffix).app")+ let preparation = Task.detached(priority: .utility) {+ try Self.prepareValidatedInstallation(+ installedAppURL: installedAppURL,+ downloadedAppURL: downloadedAppURL,+ installedExpectation: .init(bundleIdentifier: identifier, version: version, build: build),+ expectedVersion: expectedVersion,+ backupURL: backupURL,+ isRollback: isRollback+ )+ }+ let installation = try await withTaskCancellationHandler {+ try await preparation.value+ } onCancel: {+ preparation.cancel()}self.availableUpdateVersion = nilself.availableChannelRevision = nil-- // Installation is finished. Do not leave the floating progress window owned by- // the old process until it exits: quitting may be delayed or cancelled by AppKit.- // Keep the operation gate active so that old process cannot start another install.self.dismissUpdateInstallStatus()-- // Use modern NSWorkspace API for more reliable app launching- DispatchQueue.main.async {- DebugLogger.shared.info("SimpleUpdater: Attempting to relaunch app at: \(finalAppURL.path)", source: "SimpleUpdater")-- // Verify the app exists before trying to launch- guard FileManager.default.fileExists(atPath: finalAppURL.path) else {- DebugLogger.shared.error("SimpleUpdater: ERROR - App not found at expected location: \(finalAppURL.path)", source: "SimpleUpdater")- self.resetUpdateOperation()- // Don't terminate if we can't find the new app- return- }-- let configuration = NSWorkspace.OpenConfiguration()- configuration.createsNewApplicationInstance = true-- NSWorkspace.shared.openApplication(at: finalAppURL, configuration: configuration) { _, error in- if let error = error {- DebugLogger.shared.error("SimpleUpdater: Failed to relaunch app: \(error)", source: "SimpleUpdater")- DebugLogger.shared.error("SimpleUpdater: App location: \(finalAppURL.path)", source: "SimpleUpdater")- Task { @MainActor in- self.resetUpdateOperation()- }- // Don't terminate if relaunch failed - let user manually restart+ let configuration = NSWorkspace.OpenConfiguration()+ configuration.createsNewApplicationInstance = true+ NSWorkspace.shared.openApplication(at: installedAppURL, configuration: configuration) { application, error in+ Task { @MainActor in+ guard error == nil, let application else {+ await self.recoverFailedRelaunch(installation, error: error)return}-- DebugLogger.shared.info("SimpleUpdater: Successfully relaunched app, terminating old instance", source: "SimpleUpdater")- // Give the new instance time to fully start before terminating- DispatchQueue.main.asyncAfter(deadline: .now() + 2.0) {- UpdateTerminationScheduler.requestTermination()+ // Keep the outgoing app and shared lock through the existing startup+ // grace period; a newly launched process must not start another swap.+ try? await Task.sleep(for: .seconds(2))+ guard !application.isTerminated else {+ await self.recoverFailedRelaunch(installation, error: nil)+ return+ }+ // Keep the shared lock while pruning so another process cannot+ // create a backup that this operation mistakes for an old one.+ var protected: Set<URL> = [installation.backupURL]+ if isRollback { protected.insert(downloadedAppURL) }+ await self.pruneRollbackBackups(preserving: protected)+ guard !application.isTerminated else {+ await self.recoverFailedRelaunch(installation, error: nil)+ return+ }+ let cleanupWarning = await Task.detached(priority: .utility) {+ do {+ try installation.replacement.finalize()+ return String?.none+ } catch {+ return error.localizedDescription+ }+ }.value+ if let cleanupWarning {+ DebugLogger.shared.warning("SimpleUpdater: Update completed; cleanup failed: \(cleanupWarning)", source: "SimpleUpdater")}+ UpdateTerminationScheduler.requestTermination()+ }+ }+ }++ private func recoverFailedRelaunch(_ installation: PreparedInstallation, error: Error?) async {+ let recoveryWarning = await Task.detached(priority: .utility) {+ do {+ try installation.replacement.recover()+ return String?.none+ } catch {+ return error.localizedDescription}+ }.value+ self.resetUpdateOperation()+ if let error {+ DebugLogger.shared.error("SimpleUpdater: Relaunch failed: \(error.localizedDescription)", source: "SimpleUpdater")+ }+ if let recoveryWarning {+ DebugLogger.shared.error("SimpleUpdater: Recovery failed; saved app at \(installation.backupURL.path): \(recoveryWarning)", source: "SimpleUpdater")}+ self.showUpdateCheckResult(+ title: "Update Failed",+ message: recoveryWarning == nil+ ? "The new app could not start. Your previous version has been restored. Please try again."+ : "The app could not restart. Your previous version is saved at \(installation.backupURL.path)."+ )}}diff --git a/Sources/Fluid/Services/SpeechModelFeed.swift b/Sources/Fluid/Services/SpeechModelFeed.swiftnew file mode 100644index 00000000..7943b0c8--- /dev/null+++ b/Sources/Fluid/Services/SpeechModelFeed.swift@@ -0,0 +1,103 @@+import CryptoKit+import Foundation++/// The signed list of current speech model releases. Rules and format: docs/MODEL_UPDATE_FEED.md.+/// Foundation and CryptoKit only: Tools/model-release compiles this file to check a feed before it is published.+nonisolated enum SpeechModelFeed {+ struct Entry: Codable, Equatable, Sendable {+ let release: String+ let url: URL+ let bytes: Int64+ let sha256: String+ let manifestSHA256: String+ let format: Int+ let minBuild: Int+ }++ struct Payload: Codable, Equatable, Sendable {+ let schema: Int+ let sequence: Int+ let models: [String: [String: [Entry]]]+ }++ enum Rejection: String, Error, Equatable {+ case tooLarge+ case notAnEnvelope+ case badSignature+ case unreadablePayload+ case unknownSchema+ case staleSequence+ case badEntry+ }++ static let schema = 1+ static let maximumEnvelopeBytes = 64 * 1024+ static let host = "models.fluidvoice.app"+ static let pathPrefix = "/parakeet/"+ static let byteRange: ClosedRange<Int64> = 20_000_000...1_000_000_000++ private struct Envelope: Decodable {+ let payload: String+ let signature: String+ }++ /// The payload when the envelope is signed by one of `publicKeys` and every field of every entry is valid.+ static func verified(envelope: Data, publicKeys: [String], lastSequence: Int) throws -> Payload {+ guard envelope.count <= self.maximumEnvelopeBytes else { throw Rejection.tooLarge }+ guard let decoded = try? JSONDecoder().decode(Envelope.self, from: envelope),+ let payloadBytes = Data(base64Encoded: decoded.payload),+ let signature = Data(base64Encoded: decoded.signature)+ else { throw Rejection.notAnEnvelope }++ let signed = publicKeys.contains { key in+ guard let raw = Data(base64Encoded: key),+ let publicKey = try? Curve25519.Signing.PublicKey(rawRepresentation: raw)+ else { return false }+ return publicKey.isValidSignature(signature, for: payloadBytes)+ }+ guard signed else { throw Rejection.badSignature }++ guard let payload = try? JSONDecoder().decode(Payload.self, from: payloadBytes) else {+ throw Rejection.unreadablePayload+ }+ guard payload.schema == self.schema else { throw Rejection.unknownSchema }+ guard payload.sequence >= 1, payload.sequence >= lastSequence else { throw Rejection.staleSequence }+ let entries = payload.models.values.flatMap { $0.values.flatMap { $0 } }+ guard entries.allSatisfy(self.isValid) else { throw Rejection.badEntry }+ return payload+ }++ /// Lists are newest first; the first release this build can run wins.+ static func entry(+ in payload: Payload,+ model: String,+ platform: String,+ build: Int,+ supportedFormat: Int+ ) -> Entry? {+ payload.models[model]?[platform]?.first { $0.format <= supportedFormat && $0.minBuild <= build }+ }++ static func isValid(_ entry: Entry) -> Bool {+ let releaseCharacters = CharacterSet(charactersIn: "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ.-")+ guard !entry.release.isEmpty, entry.release.count <= 32,+ entry.release.unicodeScalars.allSatisfy(releaseCharacters.contains)+ else { return false }++ let url = entry.url+ let pathComponents = url.path.split(separator: "/", omittingEmptySubsequences: false).dropFirst()+ guard url.scheme == "https", url.host == self.host, url.port == nil, url.user == nil, url.password == nil,+ url.query == nil, url.fragment == nil,+ url.path.hasPrefix(self.pathPrefix), url.path.hasSuffix(".tar"),+ pathComponents.allSatisfy({ !$0.isEmpty && $0 != "." && $0 != ".." })+ else { return false }++ return self.isSHA256(entry.sha256) && self.isSHA256(entry.manifestSHA256)+ && self.byteRange.contains(entry.bytes)+ && entry.format >= 1 && entry.minBuild >= 1+ }++ private static func isSHA256(_ value: String) -> Bool {+ value.utf8.count == 64 && value.utf8.allSatisfy { (48...57).contains($0) || (97...102).contains($0) }+ }+}diff --git a/Sources/Fluid/Services/SpeechModelInstallationSnapshot.swift b/Sources/Fluid/Services/SpeechModelInstallationSnapshot.swiftnew file mode 100644index 00000000..9732abca--- /dev/null+++ b/Sources/Fluid/Services/SpeechModelInstallationSnapshot.swift@@ -0,0 +1,259 @@+import Combine+import Foundation+#if canImport(FluidAudio)+import FluidAudio+#endif++/// UI reads immutable IDs. Only an event-triggered worker inspects downloaded files.+@MainActor+final class SpeechModelInstallationSnapshot: ObservableObject {+ static let shared = SpeechModelInstallationSnapshot()++ nonisolated enum State: Equatable, Sendable {+ case checking, ready, failed+ }++ nonisolated struct Probe: Sendable {+ nonisolated enum Kind: Sendable {+ case builtIn+ case parakeet(ParakeetSpeechModelCatalog.Descriptor)+ case realtime(folder: String, requiredModels: [String])+ case cohere(ExternalCoreMLASRModelSpec, storedPath: String?)+ case nemotron(folder: String)+ case whisper(file: String, expectedBytes: Int64)+ case unavailable+ }++ let modelID: String+ let kind: Kind+ var rejectedManifestHashes: Set<String> = []+ }++ nonisolated struct ScanResult: Equatable, Sendable {+ let installedIDs: Set<String>+ let updateAvailableIDs: Set<String>+ let installedArchiveHashes: [String: String]+ let installedManifestHashes: [String: String]++ init(installedIDs: Set<String>, updateAvailableIDs: Set<String> = [], installedArchiveHashes: [String: String] = [:], installedManifestHashes: [String: String] = [:]) {+ self.installedIDs = installedIDs+ self.updateAvailableIDs = updateAvailableIDs+ self.installedArchiveHashes = installedArchiveHashes+ self.installedManifestHashes = installedManifestHashes+ }+ }++ nonisolated struct Value: Equatable, Sendable {+ let state: State+ let result: ScanResult+ let latestDescriptors: [String: ParakeetSpeechModelCatalog.Descriptor]+ }++ typealias Scanner = @Sendable ([Probe]) async throws -> Set<String>+ typealias ResultScanner = @Sendable ([Probe]) async throws -> ScanResult+ @Published private(set) var value = Value(state: .checking, result: ScanResult(installedIDs: []), latestDescriptors: [:])+ var installedIDs: Set<String> { self.value.result.installedIDs }+ var updateAvailableIDs: Set<String> { self.value.result.updateAvailableIDs }+ var installedArchiveHashes: [String: String] { self.value.result.installedArchiveHashes }+ var installedManifestHashes: [String: String] { self.value.result.installedManifestHashes }+ var latestDescriptors: [String: ParakeetSpeechModelCatalog.Descriptor] { self.value.latestDescriptors }+ var state: State { self.value.state }+ var isChecking: Bool { self.state == .checking }+ var canUseModelActions: Bool { self.state == .ready }++ private let capture: @MainActor () -> [Probe]+ private let scanner: ResultScanner+ private let timeoutNanoseconds: UInt64+ private var generation: UInt64 = 0+ private var pending: (generation: UInt64, probes: [Probe])?+ private var worker: Task<Void, Never>?+ private var deadline: Task<Void, Never>?+ private var deadlineID: UUID?++ init(+ timeoutNanoseconds: UInt64 = 5_000_000_000,+ capture: @escaping @MainActor () -> [Probe] = SpeechModelInstallationSnapshot.captureProbes,+ scanner: Scanner? = nil,+ resultScanner: @escaping ResultScanner = { try await SpeechModelInstallationSnapshot.scanResult($0) }+ ) {+ self.timeoutNanoseconds = timeoutNanoseconds+ self.capture = capture+ if let scanner {+ self.scanner = { try ScanResult(installedIDs: await scanner($0)) }+ } else {+ self.scanner = resultScanner+ }+ }++ func isInstalled(modelID: String) -> Bool { self.installedIDs.contains(modelID) }+ func isUpdateAvailable(modelID: String) -> Bool { self.updateAvailableIDs.contains(modelID) }++ /// A display/profile key lookup only; it never starts download or reads disk.+ func installedDescriptor(for model: SettingsStore.SpeechModel) -> ParakeetSpeechModelCatalog.Descriptor? {+ guard let descriptor = self.latestDescriptors[model.id], let hash = self.installedArchiveHashes[model.id] else { return nil }+ return descriptor.replacingArchive(url: nil, sha256: hash, manifestSHA256: self.installedManifestHashes[model.id])+ }++ /// Keep at most one worker and one latest request. Byte-progress callbacks never call this.+ func refresh() {+ self.generation &+= 1+ self.pending = (self.generation, self.capture())+ self.value = Value(state: .checking, result: self.value.result, latestDescriptors: self.value.latestDescriptors)+ if self.deadline == nil {+ let id = UUID()+ self.deadlineID = id+ self.deadline = Task { [weak self, timeoutNanoseconds] in+ do { try await Task.sleep(nanoseconds: timeoutNanoseconds) } catch { return }+ guard !Task.isCancelled, let self, self.deadlineID == id, self.state == .checking else { return }+ self.cancel()+ }+ }+ self.startWorkerIfNeeded()+ }++ /// A slow/unavailable volume has a visible bounded exit. A canceled worker must+ /// actually drain before a replacement starts, even when filesystem IO cannot cancel.+ func cancel() {+ self.generation &+= 1+ self.pending = nil+ self.worker?.cancel()+ self.deadline?.cancel()+ self.deadline = nil+ self.deadlineID = nil+ self.value = Value(state: .failed, result: ScanResult(installedIDs: []), latestDescriptors: self.value.latestDescriptors)+ }++ private func startWorkerIfNeeded() {+ guard self.worker == nil, self.pending != nil else { return }+ self.worker = Task { [weak self] in+ guard let self else { return }+ while !Task.isCancelled, let request = self.pending {+ self.pending = nil+ do {+ let installed = try await self.scanner(request.probes)+ guard !Task.isCancelled, request.generation == self.generation else { continue }+ let descriptors = Dictionary(request.probes.compactMap { probe -> (String, ParakeetSpeechModelCatalog.Descriptor)? in+ guard case let .parakeet(descriptor) = probe.kind else { return nil }+ return (probe.modelID, descriptor)+ }, uniquingKeysWith: { _, latest in latest })+ self.value = Value(state: .ready, result: installed, latestDescriptors: descriptors)+ self.finishDeadline()+ } catch {+ guard !Task.isCancelled, request.generation == self.generation else { continue }+ self.value = Value(state: .failed, result: ScanResult(installedIDs: []), latestDescriptors: self.value.latestDescriptors)+ self.finishDeadline()+ }+ }+ self.worker = nil+ self.startWorkerIfNeeded()+ }+ }++ private func finishDeadline() {+ self.deadline?.cancel()+ self.deadline = nil+ self.deadlineID = nil+ }++ private static func captureProbes() -> [Probe] {+ let releases = CompactSpeechModelReleaseCatalog.shared+ return SettingsStore.SpeechModel.availableModels.map { model in+ let kind: Probe.Kind+ if let descriptor = CompactSpeechModelReleaseCatalog.shared.descriptor(for: model) ?? model.parakeetDescriptor {+ kind = .parakeet(descriptor)+ } else if let spec = model.externalCoreMLSpec {+ kind = .cohere(spec, storedPath: SettingsStore.shared.storedExternalCoreMLArtifactsPath(for: model))+ } else if let file = model.whisperModelFile {+ kind = .whisper(file: file, expectedBytes: model.expectedDownloadBytes)+ } else {+ switch model {+ case .appleSpeech, .appleSpeechAnalyzer:+ kind = .builtIn+ case .parakeetRealtime:+ #if canImport(FluidAudio)+ kind = .realtime(folder: Repo.parakeetEou160.folderName, requiredModels: Array(ModelNames.ParakeetEOU.requiredModels).sorted())+ #else+ kind = .unavailable+ #endif+ case .nemotronOffline:+ kind = .nemotron(folder: "nemotron-3.5-asr-offline-6bit-CoreML")+ case .nemotronStreaming, .nemotronStreaming320:+ kind = .nemotron(folder: "nemotron-3.5-asr-streaming320-int8-CoreML")+ default:+ kind = .unavailable+ }+ }+ return Probe(modelID: model.id, kind: kind, rejectedManifestHashes: releases.descriptor(for: model) == nil ? [] : releases.snapshot.rejectedManifestHashes)+ }+ }++ @concurrent static func scan(_ probes: [Probe], cachesDirectory: URL? = nil, modelsDirectory: URL? = nil) async throws -> Set<String> {+ try await self.scanResult(probes, cachesDirectory: cachesDirectory, modelsDirectory: modelsDirectory).installedIDs+ }++ @concurrent static func scanResult(_ probes: [Probe], cachesDirectory: URL? = nil, modelsDirectory: URL? = nil) async throws -> ScanResult {+ var installed: Set<String> = []+ var updates: Set<String> = []+ var hashes: [String: String] = [:]+ var manifests: [String: String] = [:]+ let fm = FileManager.default+ let caches = cachesDirectory ?? fm.urls(for: .cachesDirectory, in: .userDomainMask).first+ let models = modelsDirectory ?? fm.urls(for: .applicationSupportDirectory, in: .userDomainMask).first?+ .appendingPathComponent("FluidAudio/Models", isDirectory: true)+ for probe in probes {+ try Task.checkCancellation()+ let exists: Bool+ switch probe.kind {+ case .builtIn:+ exists = true+ case let .parakeet(descriptor):+ if descriptor.variant == .mini || descriptor.variant == .pico {+ let hash = models.flatMap { descriptor.installedArchiveSHA256(at: descriptor.cacheDirectory(in: $0)) }+ exists = hash != nil+ if let hash {+ hashes[probe.modelID] = hash+ let manifest = models.flatMap { descriptor.installedManifestSHA256(at: descriptor.cacheDirectory(in: $0)) }+ if let manifest { manifests[probe.modelID] = manifest }+ let differs: Bool+ if let latest = descriptor.manifestSHA256, let manifest {+ differs = latest != manifest+ } else {+ // Legacy complete caches with the same tar need no redundant download.+ differs = hash != descriptor.archiveSHA256+ }+ let rejected = descriptor.manifestSHA256.map { probe.rejectedManifestHashes.contains($0) } ?? false+ if differs, !rejected { updates.insert(probe.modelID) }+ }+ } else {+ exists = models.map { descriptor.artifactsAreComplete(at: descriptor.cacheDirectory(in: $0)) } ?? false+ }+ case let .realtime(folder, requiredModels):+ let directory = models?.appendingPathComponent("parakeet-eou-streaming", isDirectory: true)+ .appendingPathComponent(folder, isDirectory: true)+ exists = directory.map { root in+ requiredModels.allSatisfy {+ HuggingFaceModelDownloader.artifactIsComplete(at: root.appendingPathComponent($0), isDirectory: $0.hasSuffix(".mlmodelc"))+ }+ } ?? false+ case let .cohere(spec, storedPath):+ let directory = storedPath.map { URL(fileURLWithPath: $0, isDirectory: true) } ?? spec.defaultCacheDirectory+ exists = directory.map { spec.validatesInstalledArtifacts(at: $0) } ?? false+ case let .nemotron(folder):+ #if arch(arm64)+ exists = caches.map { NemotronProvider.artifactsAreComplete(at: $0.appendingPathComponent(folder, isDirectory: true)) } ?? false+ #else+ exists = false+ #endif+ case let .whisper(file, expectedBytes):+ let url = caches?.appendingPathComponent("WhisperModels", isDirectory: true).appendingPathComponent(file)+ let attributes = url.flatMap { try? fm.attributesOfItem(atPath: $0.path) }+ exists = expectedBytes > 0 && (attributes?[.size] as? NSNumber)?.int64Value == expectedBytes+ case .unavailable:+ exists = false+ }+ if exists { installed.insert(probe.modelID) }+ }+ try Task.checkCancellation()+ return ScanResult(installedIDs: installed, updateAvailableIDs: updates, installedArchiveHashes: hashes, installedManifestHashes: manifests)+ }+}diff --git a/Sources/Fluid/Services/UpdateAppReplacement.swift b/Sources/Fluid/Services/UpdateAppReplacement.swiftnew file mode 100644index 00000000..c8fdc7e8--- /dev/null+++ b/Sources/Fluid/Services/UpdateAppReplacement.swift@@ -0,0 +1,285 @@+import Darwin+import Foundation++/// Copies the incoming bundle, then exchanges it atomically with the installed bundle.+/// The caller validates `stagedAppURL` and saves its durable rollback backup before commit.+/// All methods perform disk IO and must run outside the main actor.+final nonisolated class UpdateAppReplacement: @unchecked Sendable {+ nonisolated struct Operations: Sendable {+ var createDirectory: @Sendable (URL) throws -> Void+ var copyBundle: @Sendable (URL, URL) throws -> Void+ var exchangeBundles: @Sendable (URL, URL) throws -> Void+ var removeDirectory: @Sendable (URL) throws -> Void++ static let live = Operations(+ createDirectory: { url in+ try FileManager.default.createDirectory(+ at: url,+ withIntermediateDirectories: false,+ attributes: [.posixPermissions: 0o700]+ )+ },+ copyBundle: { source, destination in+ try FileManager.default.copyItem(at: source, to: destination)+ },+ exchangeBundles: { installed, staged in+ let result = installed.withUnsafeFileSystemRepresentation { installedPath in+ staged.withUnsafeFileSystemRepresentation { stagedPath in+ renameatx_np(AT_FDCWD, installedPath, AT_FDCWD, stagedPath, UInt32(RENAME_SWAP))+ }+ }+ guard result == 0 else {+ throw NSError(domain: NSPOSIXErrorDomain, code: Int(errno))+ }+ },+ removeDirectory: { url in+ do {+ try FileManager.default.removeItem(at: url)+ } catch let error as CocoaError where error.code == .fileNoSuchFile {+ // Cleanup is idempotent after a completed prior attempt.+ }+ }+ )+ }++ nonisolated enum Operation: String, Sendable {+ case preparation, commit, recovery, cleanup+ }++ nonisolated struct Failure: LocalizedError {+ let operation: Operation+ let recoveryDirectoryURL: URL?+ let underlyingError: Error++ var errorDescription: String? {+ let recovery = self.recoveryDirectoryURL.map { " Recovery files: \($0.path)." } ?? ""+ return "App replacement \(self.operation.rawValue) failed: \(self.underlyingError.localizedDescription).\(recovery)"+ }+ }++ private enum State {+ case prepared, committed, restored, discarded, finalized+ }++ let installedAppURL: URL+ let stagedAppURL: URL+ let stagingDirectoryURL: URL+ /// After commit this contains the outgoing bundle, until recovery or finalization.+ var recoveryAppURL: URL { self.stagedAppURL }+ private let operations: Operations+ private var processLock: ProcessLock?+ private let installedIdentity: BundleIdentity+ private var stagedIdentity: BundleIdentity?+ private let lock = NSLock()+ private var state = State.prepared++ private init(installedAppURL: URL, stagingDirectoryURL: URL, operations: Operations, processLock: ProcessLock, installedIdentity: BundleIdentity) {+ self.installedAppURL = installedAppURL+ self.stagingDirectoryURL = stagingDirectoryURL+ self.stagedAppURL = stagingDirectoryURL.appendingPathComponent(installedAppURL.lastPathComponent, isDirectory: true)+ self.operations = operations+ self.processLock = processLock+ self.installedIdentity = installedIdentity+ }++ static func prepare(+ installedAppURL: URL,+ replacementAppURL: URL,+ validateInstalledApp: (@Sendable (URL) throws -> Void)? = nil,+ operations: Operations = .live+ ) throws -> UpdateAppReplacement {+ try self.requireRealBundleDirectory(installedAppURL)+ try self.requireRealBundleDirectory(replacementAppURL)+ // A retained recovery/cleanup directory blocks another attempt rather than+ // accumulating new copies or destroying recovery files from a prior attempt.+ let directory = installedAppURL.deletingLastPathComponent()+ .appendingPathComponent(".fluidvoice-update-\(installedAppURL.lastPathComponent).staging", isDirectory: true)+ let processLock = try ProcessLock(installedAppURL: installedAppURL)+ let transaction = try UpdateAppReplacement(+ installedAppURL: installedAppURL,+ stagingDirectoryURL: directory,+ operations: operations,+ processLock: processLock,+ installedIdentity: BundleIdentity(installedAppURL)+ )+ var createdDirectory = false+ do {+ // Revalidate under the process-shared lock, including normal attempts.+ try validateInstalledApp?(installedAppURL)+ if FileManager.default.fileExists(atPath: directory.path) {+ try transaction.discardStaleStage(validateInstalledApp: validateInstalledApp)+ }+ try operations.createDirectory(directory)+ createdDirectory = true+ try transaction.ownershipData.write(to: transaction.ownershipURL, options: .atomic)+ try operations.copyBundle(replacementAppURL, transaction.stagedAppURL)+ transaction.stagedIdentity = try BundleIdentity(transaction.stagedAppURL)+ return transaction+ } catch {+ guard createdDirectory else {+ throw Failure(+ operation: .preparation,+ recoveryDirectoryURL: FileManager.default.fileExists(atPath: directory.path) ? directory : nil,+ underlyingError: error+ )+ }+ do {+ try operations.removeDirectory(directory)+ } catch let cleanupError {+ throw Failure(operation: .cleanup, recoveryDirectoryURL: directory, underlyingError: cleanupError)+ }+ throw Failure(operation: .preparation, recoveryDirectoryURL: nil, underlyingError: error)+ }+ }++ /// No delete/move fallback: exchange failure leaves the installed bundle in place.+ func commit() throws {+ self.lock.lock()+ defer { self.lock.unlock() }+ guard self.state == .prepared else { throw self.invalidState(.commit) }+ do {+ try Self.requireRealBundleDirectory(self.installedAppURL)+ try Self.requireRealBundleDirectory(self.stagedAppURL)+ guard try BundleIdentity(self.installedAppURL) == self.installedIdentity,+ try BundleIdentity(self.stagedAppURL) == self.stagedIdentity+ else { throw CocoaError(.fileWriteFileExists) }+ try self.operations.exchangeBundles(self.installedAppURL, self.stagedAppURL)+ self.state = .committed+ } catch {+ throw Failure(operation: .commit, recoveryDirectoryURL: self.stagingDirectoryURL, underlyingError: error)+ }+ }++ /// Cancels staging after validation/backup/commit failure without touching the installed app.+ func discardPrepared() throws {+ self.lock.lock()+ defer { self.lock.unlock() }+ guard self.state == .prepared || self.state == .discarded else { throw self.invalidState(.cleanup) }+ guard self.processLock != nil else { return }+ self.state = .discarded+ try self.cleanup()+ }++ /// Restores the outgoing app after a failed relaunch. A failed exchange retains it for retry.+ func recover() throws {+ self.lock.lock()+ defer { self.lock.unlock() }+ if self.state == .committed {+ do {+ guard try BundleIdentity(self.installedAppURL) == self.stagedIdentity,+ try BundleIdentity(self.stagedAppURL) == self.installedIdentity+ else { throw CocoaError(.fileWriteFileExists) }+ try self.operations.exchangeBundles(self.installedAppURL, self.stagedAppURL)+ self.state = .restored+ } catch {+ throw Failure(operation: .recovery, recoveryDirectoryURL: self.stagingDirectoryURL, underlyingError: error)+ }+ } else if self.state != .restored {+ throw self.invalidState(.recovery)+ }+ guard self.processLock != nil else { return }+ try self.cleanup()+ }++ /// Call only after successful relaunch, with a durable precommit backup already retained.+ /// Recursive cleanup can partially fail; it must never trigger recovery afterward.+ func finalize() throws {+ self.lock.lock()+ defer { self.lock.unlock() }+ guard self.state == .committed || self.state == .finalized else { throw self.invalidState(.cleanup) }+ guard self.processLock != nil else { return }+ self.state = .finalized+ try self.cleanup()+ }++ private func cleanup() throws {+ do {+ try self.operations.removeDirectory(self.stagingDirectoryURL)+ self.processLock = nil+ } catch {+ throw Failure(operation: .cleanup, recoveryDirectoryURL: self.stagingDirectoryURL, underlyingError: error)+ }+ }++ private func invalidState(_ operation: Operation) -> Failure {+ Failure(+ operation: operation,+ recoveryDirectoryURL: self.stagingDirectoryURL,+ underlyingError: CocoaError(.fileWriteUnknown)+ )+ }++ private var ownershipURL: URL { self.stagingDirectoryURL.appendingPathComponent("ownership") }+ private var ownershipData: Data {+ Data("FluidVoiceUpdateStage-v1\n\(self.installedAppURL.standardizedFileURL.path)\n".utf8)+ }++ private func discardStaleStage(validateInstalledApp: (@Sendable (URL) throws -> Void)?) throws {+ let attributes = try FileManager.default.attributesOfItem(atPath: self.stagingDirectoryURL.path)+ let markerAttributes = try FileManager.default.attributesOfItem(atPath: self.ownershipURL.path)+ guard validateInstalledApp != nil,+ attributes[.type] as? FileAttributeType == .typeDirectory,+ markerAttributes[.type] as? FileAttributeType == .typeRegular,+ (markerAttributes[.size] as? NSNumber)?.intValue == self.ownershipData.count,+ try Data(contentsOf: self.ownershipURL) == self.ownershipData+ else { throw CocoaError(.fileWriteFileExists) }+ // Installed validation already passed under this lock. Remove this one known+ // orphan only; no other sibling bundles or recovery paths are enumerated.+ try self.operations.removeDirectory(self.stagingDirectoryURL)+ }++ private static func requireRealBundleDirectory(_ url: URL) throws {+ let attributes = try FileManager.default.attributesOfItem(atPath: url.path)+ guard url.isFileURL, url.pathExtension == "app", attributes[.type] as? FileAttributeType == .typeDirectory else {+ throw CocoaError(.fileReadInvalidFileName)+ }+ }++ private struct BundleIdentity: Equatable, Sendable {+ private let device: dev_t+ private let inode: ino_t++ init(_ url: URL) throws {+ var status = stat()+ guard lstat(url.path, &status) == 0,+ status.st_mode & mode_t(S_IFMT) == mode_t(S_IFDIR)+ else { throw CocoaError(.fileReadInvalidFileName) }+ self.device = status.st_dev+ self.inode = status.st_ino+ }+ }++ /// The lock file is intentionally retained: unlinking it could let another+ /// process lock a different inode while this transaction still owns the old one.+ private final class ProcessLock {+ private let descriptor: Int32++ init(installedAppURL: URL) throws {+ let url = installedAppURL.deletingLastPathComponent()+ .appendingPathComponent(".fluidvoice-update-\(installedAppURL.lastPathComponent).lock")+ let descriptor = url.withUnsafeFileSystemRepresentation { path in+ guard let path else { return Int32(-1) }+ return Darwin.open(path, O_CREAT | O_RDWR | O_NOFOLLOW | O_CLOEXEC, mode_t(0o600))+ }+ guard descriptor >= 0 else { throw NSError(domain: NSPOSIXErrorDomain, code: Int(errno)) }+ var status = stat()+ guard fstat(descriptor, &status) == 0,+ status.st_mode & mode_t(S_IFMT) == mode_t(S_IFREG),+ status.st_uid == geteuid(), status.st_nlink == 1+ else {+ Darwin.close(descriptor)+ throw CocoaError(.fileWriteInvalidFileName)+ }+ guard flock(descriptor, LOCK_EX | LOCK_NB) == 0 else {+ let error = NSError(domain: NSPOSIXErrorDomain, code: Int(errno))+ Darwin.close(descriptor)+ throw error+ }+ self.descriptor = descriptor+ }++ deinit {+ Darwin.close(self.descriptor)+ }+ }+}diff --git a/Sources/Fluid/Services/UpdateBundleValidator.swift b/Sources/Fluid/Services/UpdateBundleValidator.swiftnew file mode 100644index 00000000..f8727d60--- /dev/null+++ b/Sources/Fluid/Services/UpdateBundleValidator.swift@@ -0,0 +1,196 @@+import Foundation+import Security++/// Synchronous disk/security work. Call from the updater's background staging pipeline.+/// The caller must keep the validated bundle unchanged until the filesystem exchange.+nonisolated enum UpdateBundleValidator {+ struct Expectation: Sendable {+ let bundleIdentifier: String+ /// Exact approved release version. Nil is only for inspecting an installed/rollback bundle.+ let version: String?+ /// GitHub tags do not publish build numbers; nil still requires a valid numeric build.+ let build: String?++ init(bundleIdentifier: String, version: String?, build: String? = nil) {+ self.bundleIdentifier = bundleIdentifier+ self.version = version+ self.build = build+ }+ }++ enum SigningPolicy: Sendable {+ /// Downloaded releases must use this policy, including in Debug builds.+ case developerID(allowedTeamIDs: Set<String>)+ /// Only for local development builds and their rollback backups/tests.+ case appleDevelopment(allowedTeamIDs: Set<String>)+ /// Installed apps/rollback backups can use either approved signing certificate kind.+ /// Never use this broader policy for a downloaded release.+ case installedApp(allowedTeamIDs: Set<String>)++ var allowedTeamIDs: Set<String> {+ switch self {+ case let .developerID(teams), let .appleDevelopment(teams), let .installedApp(teams): return teams+ }+ }++ var certificateRequirement: String {+ switch self {+ case .developerID:+ return "certificate 1[field.1.2.840.113635.100.6.2.6] exists and certificate leaf[field.1.2.840.113635.100.6.1.13] exists"+ case .appleDevelopment:+ return "certificate leaf[field.1.2.840.113635.100.6.1.2] exists"+ case .installedApp:+ return "((certificate 1[field.1.2.840.113635.100.6.2.6] exists and certificate leaf[field.1.2.840.113635.100.6.1.13] exists) or certificate leaf[field.1.2.840.113635.100.6.1.2] exists)"+ }+ }+ }++ struct ValidatedBundle: Equatable, Sendable {+ let bundleIdentifier: String+ let version: String+ let build: String+ let teamIdentifier: String+ }++ enum ValidationError: LocalizedError, Equatable {+ case invalidBundle+ case invalidExpectation+ case invalidSignature(OSStatus)+ case missingSigningMetadata+ case invalidBundleMetadata+ case identityMismatch+ case versionMismatch+ case buildMismatch++ var errorDescription: String? {+ switch self {+ case .invalidBundle: return "The update is not a valid application bundle."+ case .invalidExpectation: return "The update's expected identity or signing policy is invalid."+ case .invalidSignature: return "The update's signature or sealed contents could not be verified."+ case .missingSigningMetadata: return "The update has no trusted signing identity."+ case .invalidBundleMetadata: return "The update has invalid application metadata."+ case .identityMismatch: return "The update belongs to a different application."+ case .versionMismatch: return "The update does not match the selected release version."+ case .buildMismatch: return "The update does not match the expected build."+ }+ }+ }++ static func validate(+ at bundleURL: URL,+ expectation: Expectation,+ policy: SigningPolicy+ ) throws -> ValidatedBundle {+ guard self.validIdentifier(expectation.bundleIdentifier),+ !policy.allowedTeamIDs.isEmpty,+ policy.allowedTeamIDs.allSatisfy(self.validTeamIdentifier),+ expectation.version.map(self.validVersion) ?? true,+ expectation.build.map(self.validBuild) ?? true+ else { throw ValidationError.invalidExpectation }++ guard bundleURL.isFileURL, bundleURL.pathExtension.lowercased() == "app",+ let values = try? bundleURL.resourceValues(forKeys: [.isDirectoryKey, .isSymbolicLinkKey]),+ values.isDirectory == true, values.isSymbolicLink != true+ else { throw ValidationError.invalidBundle }++ // Read the staged file afresh; Bundle caches can retain metadata from an earlier+ // app at the same URL. Bound the read before passing the bundle to Security.+ let plist = try self.readInfoPlist(at: bundleURL.appendingPathComponent("Contents/Info.plist"))++ var staticCode: SecStaticCode?+ let createStatus = SecStaticCodeCreateWithPath(bundleURL as CFURL, [], &staticCode)+ guard createStatus == errSecSuccess, let staticCode else {+ throw ValidationError.invalidSignature(createStatus)+ }++ let teams = policy.allowedTeamIDs.sorted().map { "certificate leaf[subject.OU] = \"\($0)\"" }.joined(separator: " or ")+ let requirementText = "anchor apple generic and \(policy.certificateRequirement) and (\(teams))"+ var requirement: SecRequirement?+ let requirementStatus = SecRequirementCreateWithString(requirementText as CFString, [], &requirement)+ guard requirementStatus == errSecSuccess, let requirement else {+ throw ValidationError.invalidSignature(requirementStatus)+ }++ // No skip-resource/executable flags and no network access. One full check also+ // verifies nested code and every executable architecture; serialize resource work.+ let flags = SecCSFlags(rawValue: kSecCSCheckAllArchitectures | kSecCSCheckNestedCode | kSecCSStrictValidate | kSecCSSingleThreaded)+ let validityStatus = SecStaticCodeCheckValidity(staticCode, flags, requirement)+ guard validityStatus == errSecSuccess else {+ throw ValidationError.invalidSignature(validityStatus)+ }++ var signingInformation: CFDictionary?+ let informationStatus = SecCodeCopySigningInformation(staticCode, SecCSFlags(rawValue: kSecCSSigningInformation), &signingInformation)+ guard informationStatus == errSecSuccess, let information = signingInformation as? [String: Any],+ let identifier = information[kSecCodeInfoIdentifier as String] as? String,+ let team = information[kSecCodeInfoTeamIdentifier as String] as? String,+ policy.allowedTeamIDs.contains(team),+ let certificates = information[kSecCodeInfoCertificates as String] as? [SecCertificate], !certificates.isEmpty,+ let cms = information[kSecCodeInfoCMS as String] as? Data, !cms.isEmpty,+ let signatureFlags = information[kSecCodeInfoFlags as String] as? NSNumber,+ signatureFlags.uint32Value & SecCodeSignatureFlags.adhoc.rawValue == 0,+ let securedPlist = information[kSecCodeInfoPList as String] as? [String: Any]+ else { throw ValidationError.missingSigningMetadata }++ guard let bundleIdentifier = plist["CFBundleIdentifier"] as? String,+ let version = plist["CFBundleShortVersionString"] as? String, self.validVersion(version),+ let build = plist["CFBundleVersion"] as? String, self.validBuild(build),+ plist["CFBundlePackageType"] as? String == "APPL",+ let executable = plist["CFBundleExecutable"] as? String,+ !executable.isEmpty, executable != ".", executable != "..", !executable.contains("/"),+ securedPlist["CFBundleIdentifier"] as? String == bundleIdentifier,+ securedPlist["CFBundleShortVersionString"] as? String == version,+ securedPlist["CFBundleVersion"] as? String == build+ else { throw ValidationError.invalidBundleMetadata }+ guard identifier == expectation.bundleIdentifier, bundleIdentifier == expectation.bundleIdentifier else {+ throw ValidationError.identityMismatch+ }+ if let expectedVersion = expectation.version, version != expectedVersion {+ throw ValidationError.versionMismatch+ }+ if let expectedBuild = expectation.build, build != expectedBuild {+ throw ValidationError.buildMismatch+ }+ return ValidatedBundle(bundleIdentifier: bundleIdentifier, version: version, build: build, teamIdentifier: team)+ }++ private static func readInfoPlist(at url: URL) throws -> [String: Any] {+ do {+ let values = try url.resourceValues(forKeys: [.isRegularFileKey, .isSymbolicLinkKey])+ guard values.isRegularFile == true, values.isSymbolicLink != true else {+ throw ValidationError.invalidBundleMetadata+ }+ let handle = try FileHandle(forReadingFrom: url)+ defer { try? handle.close() }+ let maximumSize = 1024 * 1024+ guard let data = try handle.read(upToCount: maximumSize + 1), data.count <= maximumSize,+ let plist = try PropertyListSerialization.propertyList(from: data, options: [], format: nil) as? [String: Any]+ else { throw ValidationError.invalidBundleMetadata }+ return plist+ } catch {+ throw ValidationError.invalidBundleMetadata+ }+ }++ private static func validIdentifier(_ value: String) -> Bool {+ !value.isEmpty && value.utf8.count <= 255 && value.utf8.allSatisfy {+ (65...90).contains($0) || (97...122).contains($0) || (48...57).contains($0) || $0 == 45 || $0 == 46+ }+ }++ private static func validTeamIdentifier(_ value: String) -> Bool {+ value.utf8.count == 10 && value.utf8.allSatisfy { (65...90).contains($0) || (48...57).contains($0) }+ }++ private static func validVersion(_ value: String) -> Bool {+ !value.isEmpty && value.utf8.count <= 128 && value == value.trimmingCharacters(in: .whitespacesAndNewlines)+ }++ private static func validBuild(_ value: String) -> Bool {+ guard !value.isEmpty, value.utf8.count <= 32 else { return false }+ let components = value.split(separator: ".", omittingEmptySubsequences: false)+ return (1...3).contains(components.count) && components.allSatisfy {+ !$0.isEmpty && $0.utf8.allSatisfy { (48...57).contains($0) }+ }+ }+}diff --git a/Sources/Fluid/Services/UpdateRollbackBackup.swift b/Sources/Fluid/Services/UpdateRollbackBackup.swiftnew file mode 100644index 00000000..f602283e--- /dev/null+++ b/Sources/Fluid/Services/UpdateRollbackBackup.swift@@ -0,0 +1,94 @@+import Foundation++/// Called while the app replacement's process-shared lock is held.+/// Disk and signature work must run outside the main actor.+nonisolated enum UpdateRollbackBackup {+ struct Operations: Sendable {+ var createDirectory: @Sendable (URL) throws -> Void+ var copyBundle: @Sendable (URL, URL) throws -> Void+ var publishBundle: @Sendable (URL, URL) throws -> Void+ var removeDirectory: @Sendable (URL) throws -> Void++ static let live = Operations(+ createDirectory: { url in+ try FileManager.default.createDirectory(at: url, withIntermediateDirectories: false, attributes: [.posixPermissions: 0o700])+ },+ copyBundle: { source, destination in try FileManager.default.copyItem(at: source, to: destination) },+ publishBundle: { source, destination in try FileManager.default.moveItem(at: source, to: destination) },+ removeDirectory: { url in+ do {+ try FileManager.default.removeItem(at: url)+ } catch let error as CocoaError where error.code == .fileNoSuchFile {}+ }+ )+ }++ struct Failure: LocalizedError {+ let retainedDirectoryURL: URL?+ let underlyingError: Error++ var errorDescription: String? {+ let retained = self.retainedDirectoryURL.map { " Retained backup files: \($0.path)." } ?? ""+ return "The current app could not be backed up. Nothing was replaced.\(retained) \(self.underlyingError.localizedDescription)"+ }+ }++ static func create(+ installedAppURL: URL,+ backupURL: URL,+ validate: @Sendable (URL) throws -> Void,+ operations: Operations = .live+ ) throws {+ let manager = FileManager.default+ let root = backupURL.deletingLastPathComponent()+ let directory = root.appendingPathComponent(".fluidvoice-backup-\(installedAppURL.lastPathComponent).staging", isDirectory: true)+ let marker = directory.appendingPathComponent("ownership")+ let ownership = Data("FluidVoiceRollbackBackup-v1\n\(installedAppURL.standardizedFileURL.path)\n".utf8)+ let stagedBundle = directory.appendingPathComponent(installedAppURL.lastPathComponent, isDirectory: true)+ var createdDirectory = false+ do {+ guard installedAppURL.isFileURL, backupURL.isFileURL,+ installedAppURL.pathExtension == "app", backupURL.pathExtension == "app"+ else { throw CocoaError(.fileWriteInvalidFileName) }+ // Recheck before removing any owned crash leftovers. The supplied validator+ // must enforce the running app's identity, version, build and trusted signature.+ try validate(installedAppURL)+ try manager.createDirectory(at: root, withIntermediateDirectories: true)+ if manager.fileExists(atPath: directory.path) {+ let attributes = try manager.attributesOfItem(atPath: directory.path)+ let markerAttributes = try manager.attributesOfItem(atPath: marker.path)+ guard attributes[.type] as? FileAttributeType == .typeDirectory,+ markerAttributes[.type] as? FileAttributeType == .typeRegular,+ (markerAttributes[.size] as? NSNumber)?.intValue == ownership.count,+ try Data(contentsOf: marker) == ownership+ else { throw CocoaError(.fileWriteFileExists) }+ try operations.removeDirectory(directory)+ }+ try operations.createDirectory(directory)+ createdDirectory = true+ try ownership.write(to: marker, options: .atomic)+ try operations.copyBundle(installedAppURL, stagedBundle)+ try validate(stagedBundle)+ // Same-filesystem publication is exclusive: an existing backup is never replaced.+ try operations.publishBundle(stagedBundle, backupURL)+ } catch {+ let originalError = error+ if createdDirectory {+ do {+ try operations.removeDirectory(directory)+ } catch {+ throw Failure(retainedDirectoryURL: directory, underlyingError: error)+ }+ }+ throw Failure(+ retainedDirectoryURL: manager.fileExists(atPath: directory.path) ? directory : nil,+ underlyingError: originalError+ )+ }+ do {+ try operations.removeDirectory(directory)+ } catch {+ throw Failure(retainedDirectoryURL: directory, underlyingError: error)+ }+ }+}diff --git a/Sources/Fluid/Theme/Components/FluidVoiceBrandIcon.swift b/Sources/Fluid/Theme/Components/FluidVoiceBrandIcon.swiftnew file mode 100644index 00000000..58a06e8f--- /dev/null+++ b/Sources/Fluid/Theme/Components/FluidVoiceBrandIcon.swift@@ -0,0 +1,19 @@+import AppKit+import SwiftUI++/// Reuse AppKit's cached app icon; no asset lookup or filesystem query in the view.+struct FluidVoiceBrandIcon: View {+ private static let appIconImage: NSImage = NSApplication.shared.applicationIconImage+ ?? NSImage(size: NSSize(width: 32, height: 32))++ let size: CGFloat++ var body: some View {+ Image(nsImage: Self.appIconImage)+ .resizable()+ .interpolation(.high)+ .aspectRatio(contentMode: .fit)+ .frame(width: self.size, height: self.size)+ .accessibilityHidden(true)+ }+}diff --git a/Sources/Fluid/Theme/Components/WindowSizingComponents.swift b/Sources/Fluid/Theme/Components/WindowSizingComponents.swiftindex df458b9b..e3fbf453 100644--- a/Sources/Fluid/Theme/Components/WindowSizingComponents.swift+++ b/Sources/Fluid/Theme/Components/WindowSizingComponents.swift@@ -36,16 +36,18 @@ private struct FluidWindowSizingBridge: NSViewRepresentable {}}-private final class FluidWindowSizingNSView: NSView {+final class FluidWindowSizingNSView: NSView {var sizing: FluidWindowSizing {didSet {- self.applySizing()+ guard self.sizing != oldValue else { return }+ self.scheduleSizing()}}private weak var observedWindow: NSWindow?- private var resizeObserver: NSObjectProtocol?+ private var windowObservers: [NSObjectProtocol] = []private var isApplyingSizing = false+ private var isSizingScheduled = falseinit(sizing: FluidWindowSizing) {self.sizing = sizing@@ -64,7 +66,7 @@ private final class FluidWindowSizingNSView: NSView {override func viewDidMoveToWindow() {super.viewDidMoveToWindow()self.observeWindowIfNeeded()- self.applySizing()+ self.scheduleSizing()}private func observeWindowIfNeeded() {@@ -74,35 +76,42 @@ private final class FluidWindowSizingNSView: NSView {self.observedWindow = self.windowguard let window else { return }- self.resizeObserver = NotificationCenter.default.addObserver(- forName: NSWindow.didResizeNotification,- object: window,- queue: .main- ) { [weak self] _ in- self?.applySizing()+ self.windowObservers = [NSWindow.didResizeNotification, NSWindow.didExitFullScreenNotification].map { name in+ NotificationCenter.default.addObserver(forName: name, object: window, queue: .main) { [weak self] _ in+ self?.scheduleSizing()+ }}}private func removeResizeObserver() {- if let resizeObserver {- NotificationCenter.default.removeObserver(resizeObserver)+ for observer in self.windowObservers {+ NotificationCenter.default.removeObserver(observer)+ }+ self.windowObservers.removeAll()+ }++ private func scheduleSizing() {+ guard !self.isSizingScheduled else { return }+ self.isSizingScheduled = true+ // NSWindow bounds must not change inside SwiftUI's constraint/layout pass.+ // One deferred application reads the latest sizing and current window.+ DispatchQueue.main.async { [weak self] in+ guard let self else { return }+ self.isSizingScheduled = false+ self.applySizing()}- self.resizeObserver = nil}private func applySizing() {- guard !self.isApplyingSizing, let window else { return }+ guard !self.isApplyingSizing, let window, !window.styleMask.contains(.fullScreen) else { return }self.isApplyingSizing = truedefer { self.isApplyingSizing = false }let minSize = self.sizing.minSize- window.minSize = minSize+ if window.minSize != minSize { window.minSize = minSize }let maximumSize = self.sizing.maximumSize ?? NSSize(width: CGFloat.greatestFiniteMagnitude, height: CGFloat.greatestFiniteMagnitude)- window.maxSize = maximumSize-- // Full-screen geometry belongs to macOS, not the normal-window bounds.- guard !window.styleMask.contains(.fullScreen) else { return }+ if window.maxSize != maximumSize { window.maxSize = maximumSize }let frame = window.framelet targetWidth = min(max(frame.width, minSize.width), maximumSize.width)diff --git a/Sources/Fluid/UI/AISettings/VoiceEngineSettingsViewModel.swift b/Sources/Fluid/UI/AISettings/VoiceEngineSettingsViewModel.swiftindex 8beef037..4b45a9d2 100644--- a/Sources/Fluid/UI/AISettings/VoiceEngineSettingsViewModel.swift+++ b/Sources/Fluid/UI/AISettings/VoiceEngineSettingsViewModel.swift@@ -7,11 +7,13 @@ final class VoiceEngineSettingsViewModel: ObservableObject {let settings: SettingsStoreprivate let appServices: AppServicesprivate var cancellables = Set<AnyCancellable>()+ let installations = SpeechModelInstallationSnapshot.sharedvar asr: ASRService { self.appServices.asr }var areSpeechModelActionsBlocked: Bool {- self.asr.isRunning+ !self.installations.canUseModelActions+ || self.asr.isRunning|| self.asr.deletingModelID != nil|| self.asr.activeExclusiveActivity != nil|| self.downloadingModel != nil@@ -56,14 +58,23 @@ final class VoiceEngineSettingsViewModel: ObservableObject {}}.store(in: &self.cancellables)+ self.installations.objectWillChange+ .sink { [weak self] _ in+ Task { @MainActor in self?.objectWillChange.send() }+ }+ .store(in: &self.cancellables)}func onAppear() {self.previewSpeechModel = self.settings.selectedSpeechModelself.selectedSpeechProvider = self.settings.selectedSpeechModel.provider+ self.installations.refresh()Task {- await self.asr.checkIfModelsExistAsync()+ let catalog = CompactSpeechModelReleaseCatalog.shared+ let revision = catalog.revision+ await catalog.refreshIfNeeded()+ if catalog.revision != revision { self.installations.refresh() }}}@@ -97,7 +108,7 @@ final class VoiceEngineSettingsViewModel: ObservableObject {}if self.installedOnlyFilter {- models = models.filter { $0.isInstalled }+ models = models.filter { self.isSpeechModelInstalled($0) }}switch self.modelSortOption {@@ -134,18 +145,22 @@ final class VoiceEngineSettingsViewModel: ObservableObject {}}- func downloadSpeechModel(_ model: SettingsStore.SpeechModel) {+ func downloadSpeechModel(_ model: SettingsStore.SpeechModel, updateWeights: Bool = false) {guard !self.areSpeechModelActionsBlocked else { return }Task { [weak self] inguard let self else { return }do {- try await self.asr.downloadModel(model, progressHandler: nil)+ try await self.asr.downloadModel(model, updateWeights: updateWeights, progressHandler: nil)DebugLogger.shared.info("Model download completed: \(model.displayName)", source: "VoiceEngineVM")} catch is CancellationError {DebugLogger.shared.info("Model download cancelled: \(model.displayName)", source: "VoiceEngineVM")} catch {DebugLogger.shared.error("Failed to download model \(model.displayName): \(error)", source: "VoiceEngineVM")- self.asr.errorTitle = "Model Download Failed"+ if let failure = error as? ParakeetArchiveDownloader.DownloadError, case .replacementCleanupFailed = failure {+ self.asr.errorTitle = "Model Updated"+ } else {+ self.asr.errorTitle = updateWeights ? "Model Update Failed" : "Model Download Failed"+ }self.asr.errorMessage = error.localizedDescriptionself.asr.showError = true}@@ -172,6 +187,18 @@ final class VoiceEngineSettingsViewModel: ObservableObject {self.settings.selectedSpeechModel == model}+ func isSpeechModelInstalled(_ model: SettingsStore.SpeechModel) -> Bool {+ self.installations.isInstalled(modelID: model.id)+ }++ func isSpeechModelUpdateAvailable(_ model: SettingsStore.SpeechModel) -> Bool {+ self.installations.updateAvailableIDs.contains(model.id)+ }++ func speechModelDownloadSize(_ model: SettingsStore.SpeechModel) -> String {+ self.installations.latestDescriptors[model.id]?.downloadSize ?? model.downloadSize+ }+var modelDescriptionText: String {let model = self.settings.selectedSpeechModelswitch model {@@ -183,6 +210,8 @@ final class VoiceEngineSettingsViewModel: ObservableObject {return "Parakeet TDT v3 uses CoreML and Neural Engine for fastest transcription (25 languages) on Apple Silicon."case .parakeetTDTv2:return "Parakeet TDT v2 is an English-only model optimized for accuracy and consistency on Apple Silicon."+ case .fluidParakeetMini, .fluidParakeetPico:+ return "\(model.cardDescription) Requires Apple silicon."case .parakeetRealtime:return "Parakeet Flash uses FluidAudio's true streaming EOU pipeline for low-latency English dictation. Best when you want words to appear live as you speak."case .qwen3Asr:diff --git a/Sources/Fluid/UI/AISettingsView+SpeechRecognition.swift b/Sources/Fluid/UI/AISettingsView+SpeechRecognition.swiftindex c28aca14..0e5b3678 100644--- a/Sources/Fluid/UI/AISettingsView+SpeechRecognition.swift+++ b/Sources/Fluid/UI/AISettingsView+SpeechRecognition.swift@@ -12,7 +12,7 @@ extension VoiceEngineSettingsView {var speechRecognitionCard: some View {let selectedModel = self.settings.selectedSpeechModel- let activeModel = selectedModel.isInstalled ? selectedModel : nil+ let activeModel = self.viewModel.isSpeechModelInstalled(selectedModel) ? selectedModel : nillet hasActiveModel = activeModel != nillet otherModels = self.viewModel.filteredSpeechModels.filter { model inguard let activeModel else { return true }@@ -51,12 +51,12 @@ extension VoiceEngineSettingsView {Spacer()Menu {ForEach(SpeechProviderFilter.allCases) { option in- Button(option.rawValue) {+ Button(option.displayName) {self.viewModel.providerFilter = option}}} label: {- Text("Filter: \(self.viewModel.providerFilter.rawValue)")+ Text("Filter: \(self.viewModel.providerFilter.displayName)")}.fluidDropdownStyle()Menu {@@ -85,9 +85,17 @@ extension VoiceEngineSettingsView {Text("Active Model").font(self.theme.typography.sectionTitle).foregroundStyle(self.voiceEngineTitleText)- Label("No active model yet. Download and activate one below.", systemImage: "arrow.down.circle")- .font(self.theme.typography.bodySmall)- .foregroundStyle(self.voiceEngineSecondaryText)+ Label(+ self.viewModel.installations.isChecking ? "Checking downloaded models…"+ : (self.viewModel.installations.state == .failed ? "Couldn't check downloaded models. Try again." : "No active model yet. Download and activate one below."),+ systemImage: self.viewModel.installations.canUseModelActions ? "arrow.down.circle" : "info.circle"+ )+ .font(self.theme.typography.bodySmall)+ .foregroundStyle(self.voiceEngineSecondaryText)+ if self.viewModel.installations.state == .failed {+ Button("Retry check") { self.viewModel.installations.refresh() }+ .fluidGlassAction(quiet: true)+ }}}@@ -156,10 +164,17 @@ extension VoiceEngineSettingsView {.font(self.theme.typography.bodySmall).foregroundStyle(self.voiceEngineSecondaryText).lineLimit(2)++ if let descriptor = model.parakeetDescriptor {+ Text(descriptor.creditLine)+ .font(self.theme.typography.caption)+ .foregroundStyle(self.voiceEngineSecondaryText)+ .fixedSize(horizontal: false, vertical: true)+ }}HStack(spacing: 8) {- Label(model.downloadSize, systemImage: "internaldrive")+ Label(self.viewModel.speechModelDownloadSize(model), systemImage: "internaldrive").font(self.theme.typography.bodySmall).foregroundStyle(self.voiceEngineSecondaryText)@@ -213,25 +228,28 @@ extension VoiceEngineSettingsView {}.frame(maxWidth: .infinity, alignment: .leading)- HStack(spacing: 16) {- LiquidBar(- fillPercent: model.speedPercent,- color: .yellow,- secondaryColor: .orange,- icon: "bolt.fill",- label: "Speed"- )+ if model.hasPerformanceRatings {+ HStack(spacing: 16) {+ LiquidBar(+ fillPercent: model.speedPercent,+ color: .yellow,+ secondaryColor: .orange,+ icon: "bolt.fill",+ label: "Speed"+ )- LiquidBar(- fillPercent: model.accuracyPercent,- color: Color.fluidGreen,- secondaryColor: .cyan,- icon: "target",- label: "Accuracy"- )+ LiquidBar(+ fillPercent: model.accuracyPercent,+ color: Color.fluidGreen,+ secondaryColor: .cyan,+ icon: "target",+ label: "Accuracy"+ )+ }+ .frame(width: 140, alignment: .center)+ .help("Relative ratings for comparing models, not measured transcription accuracy.")+ .animation(.spring(response: 0.5, dampingFraction: 0.7), value: model.id)}- .frame(width: 140, alignment: .center)- .animation(.spring(response: 0.5, dampingFraction: 0.7), value: model.id)}}.padding(.vertical, 6)@@ -240,7 +258,7 @@ extension VoiceEngineSettingsView {func speechModelCard(for model: SettingsStore.SpeechModel) -> some View {let isSelected = self.viewModel.previewSpeechModel == modellet isConfiguredActive = self.viewModel.isActiveSpeechModel(model)- let isActive = isConfiguredActive && model.isInstalled && self.viewModel.asr.isAsrReady+ let isActive = isConfiguredActive && self.viewModel.isSpeechModelInstalled(model) && self.viewModel.asr.isAsrReadyreturn HStack(alignment: .top, spacing: 10) {Circle()@@ -263,22 +281,24 @@ extension VoiceEngineSettingsView {.foregroundStyle(self.voiceEngineSecondaryText)HStack(spacing: 12) {- HStack(spacing: 4) {- Image(systemName: "bolt.fill")- .font(.fluidSystem(size: 11))- .foregroundStyle(.yellow)- Text("Speed \(Int(model.speedPercent * 100))%")- .font(self.theme.typography.bodyStrong)- .foregroundStyle(self.voiceEngineSecondaryText)- }+ if model.hasPerformanceRatings {+ HStack(spacing: 4) {+ Image(systemName: "bolt.fill")+ .font(.fluidSystem(size: 11))+ .foregroundStyle(.yellow)+ Text("Speed \(Int(model.speedPercent * 100))%")+ .font(self.theme.typography.bodyStrong)+ .foregroundStyle(self.voiceEngineSecondaryText)+ }- HStack(spacing: 4) {- Image(systemName: "target")- .font(.fluidSystem(size: 11))- .foregroundStyle(Color.fluidGreen)- Text("Acc \(Int(model.accuracyPercent * 100))%")- .font(self.theme.typography.bodyStrong)- .foregroundStyle(self.voiceEngineSecondaryText)+ HStack(spacing: 4) {+ Image(systemName: "target")+ .font(.fluidSystem(size: 11))+ .foregroundStyle(Color.fluidGreen)+ Text("Acc \(Int(model.accuracyPercent * 100))%")+ .font(self.theme.typography.bodyStrong)+ .foregroundStyle(self.voiceEngineSecondaryText)+ }}if isSelected && !isActive {@@ -375,8 +395,29 @@ extension VoiceEngineSettingsView {.controlSize(.small).disabled(self.viewModel.asr.isCancellingModelPreparation)}- } else if model.isInstalled {+ } else if !self.viewModel.installations.canUseModelActions {+ if self.viewModel.installations.isChecking {+ HStack(spacing: 6) {+ ProgressView().controlSize(.mini)+ Text("Checking downloads…")+ .font(self.theme.typography.bodySmall)+ .foregroundStyle(self.voiceEngineSecondaryText)+ }+ } else {+ Button("Retry check") { self.viewModel.installations.refresh() }+ .fluidGlassAction(quiet: true)+ }+ } else if self.viewModel.isSpeechModelInstalled(model) {HStack(spacing: 8) {+ if self.viewModel.isSpeechModelUpdateAvailable(model) {+ Button("Update") {+ self.viewModel.downloadSpeechModel(model, updateWeights: true)+ }+ .fluidGlassAction(prominent: true, tone: .orange)+ .disabled(self.viewModel.areSpeechModelActionsBlocked)+ .accessibilityLabel("Update \(model.humanReadableName)")+ }+if isActive {self.speechModelLanguagePicker(for: model).disabled(self.viewModel.areSpeechModelActionsBlocked)@@ -391,7 +432,7 @@ extension VoiceEngineSettingsView {Button("Activate") {self.viewModel.activateSpeechModel(model)}- .fluidGlassAction(quiet: true)+ .fluidGlassAction(prominent: true).disabled(self.viewModel.areSpeechModelActionsBlocked)}@@ -626,6 +667,9 @@ extension VoiceEngineSettingsView {}private func speechModelSubtitle(for model: SettingsStore.SpeechModel) -> String {+ if model == .fluidParakeetMini || model == .fluidParakeetPico {+ return model.languageSupport+ }switch model {case .nemotronStreaming, .nemotronStreaming320:return "Nemotron Speech 3.5 - Streaming Capable"@@ -761,7 +805,9 @@ extension VoiceEngineSettingsView {RoundedRectangle(cornerRadius: 7, style: .continuous).fill(bgColor)- if model.usesAppleLogo {+ if model.brandName == "FluidVoice" {+ FluidVoiceBrandIcon(size: 28)+ } else if model.usesAppleLogo {Image(systemName: "apple.logo").font(.fluidSystem(size: 14, weight: .medium)).foregroundStyle(.primary)diff --git a/Sources/Fluid/UI/AISettingsView.swift b/Sources/Fluid/UI/AISettingsView.swiftindex 20e85fd8..4c845475 100644--- a/Sources/Fluid/UI/AISettingsView.swift+++ b/Sources/Fluid/UI/AISettingsView.swift@@ -75,6 +75,7 @@ enum SpeechProviderFilter: String, CaseIterable, Identifiable {case openai = "OpenAI"var id: String { self.rawValue }+ var displayName: String { self == .nvidia ? "FluidVoice / NVIDIA" : self.rawValue }}enum AISettingsLayout {diff --git a/Sources/Fluid/UI/AppSearchResultsView.swift b/Sources/Fluid/UI/AppSearchResultsView.swiftindex 6f9760d5..fb64cd13 100644--- a/Sources/Fluid/UI/AppSearchResultsView.swift+++ b/Sources/Fluid/UI/AppSearchResultsView.swift@@ -23,7 +23,26 @@ struct AppSearchResultsView: View {var body: some View {ScrollViewReader { proxy inList {- if self.service.groups.isEmpty {+ if self.service.isSearching {+ Text("Searching…")+ .font(self.theme.typography.sidebarItem)+ .foregroundStyle(.secondary)+ .padding(.horizontal, self.theme.metrics.spacing.md)+ } else if let error = self.service.searchError {+ VStack(alignment: .leading, spacing: self.theme.metrics.spacing.sm) {+ Text(error)+ .font(self.theme.typography.sidebarItem)+ .foregroundStyle(.secondary)+ .lineLimit(3)+ .fixedSize(horizontal: false, vertical: true)+ Button("Retry") { self.service.retry() }+ .buttonStyle(.plain)+ .font(self.theme.typography.sidebarItem)+ .foregroundStyle(self.theme.palette.accent)+ }+ .frame(maxWidth: .infinity, alignment: .leading)+ .padding(.horizontal, self.theme.metrics.spacing.md)+ } else if self.service.groups.isEmpty {Text("No results").font(self.theme.typography.sidebarItem).foregroundStyle(.secondary)diff --git a/Sources/Fluid/UI/CustomDictionaryView.swift b/Sources/Fluid/UI/CustomDictionaryView.swiftindex c702a473..456bd6ec 100644--- a/Sources/Fluid/UI/CustomDictionaryView.swift+++ b/Sources/Fluid/UI/CustomDictionaryView.swift@@ -23,6 +23,10 @@ struct CustomDictionaryView: View {@Environment(\.theme) private var theme@Environment(\.accessibilityReduceMotion) private var reduceMotion@EnvironmentObject private var appServices: AppServices+ @ObservedObject private var settings = SettingsStore.shared+ @ObservedObject private var modelInstallations = SpeechModelInstallationSnapshot.shared+ @State private var pronunciationRevisionNotice: String?+ @State private var pronunciationRevisionNoticeRefresh: UInt64 = 0/// A row picked in the sidebar search. Opening it is the reveal; the binding is/// cleared so the same row can be picked again later.@@ -269,6 +273,12 @@ struct CustomDictionaryView: View {HStack(spacing: 0) {ScrollView(.vertical, showsIndicators: false) {VStack(alignment: .leading, spacing: self.theme.metrics.spacing.xl) {+ if let notice = self.pronunciationRevisionNotice {+ Text(notice)+ .font(self.theme.typography.caption)+ .foregroundStyle(self.theme.palette.secondaryText)+ .fixedSize(horizontal: false, vertical: true)+ }self.trainReplacementSection}.fluidPageContent(width: .reading, alignment: .center)@@ -312,6 +322,19 @@ struct CustomDictionaryView: View {.task(id: self.revealTarget) {self.revealSearchTarget()}+ .task(id: self.pronunciationRevisionNoticeRequest) {+ self.pronunciationRevisionNotice = nil+ guard !self.formattingOnly,+ let descriptor = self.modelInstallations.installedDescriptor(for: self.settings.selectedSpeechModel),+ descriptor.variant == .mini || descriptor.variant == .pico+ else { return }+ let entryIDs = Set(self.settings.customDictionaryEntries.map(\.id))+ let profiles = await PronunciationDictionaryStore.shared.allProfiles()+ guard !Task.isCancelled,+ descriptor.pronunciationModelKey == self.modelInstallations.installedDescriptor(for: self.settings.selectedSpeechModel)?.pronunciationModelKey+ else { return }+ self.pronunciationRevisionNotice = DictionaryPronunciationRevisionPolicy.notice(profiles: profiles, descriptor: descriptor, entryIDs: entryIDs)+ }.overlay {if let confirmation = self.replacementConfirmation {ReplacementConfirmationToast(confirmation: confirmation)@@ -356,6 +379,11 @@ struct CustomDictionaryView: View {.onReceive(NotificationCenter.default.publisher(for: .parakeetVocabularyDidChange)) { _ inguard !self.formattingOnly else { return }self.entries = SettingsStore.shared.customDictionaryEntries+ self.pronunciationRevisionNoticeRefresh &+= 1+ }+ .onReceive(NotificationCenter.default.publisher(for: .settingsBackupDidRestore)) { _ in+ guard !self.formattingOnly else { return }+ self.pronunciationRevisionNoticeRefresh &+= 1}.onChange(of: self.pronunciationEnabled) { _, enabled inguard !enabled else { return }@@ -825,6 +853,10 @@ struct CustomDictionaryView: View {.fixedSize(horizontal: false, vertical: true)}+ private var pronunciationRevisionNoticeRequest: String {+ "\(self.settings.selectedSpeechModel.rawValue):\(self.modelInstallations.installedArchiveHashes[self.settings.selectedSpeechModel.id] ?? ""): \(self.pronunciationRevisionNoticeRefresh)"+ }+private var trainingRecorderPanel: some View {VStack(alignment: .leading, spacing: self.theme.metrics.spacing.md) {Text("Teach FluidVoice your pronunciation")@@ -3191,6 +3223,30 @@ enum CustomDictionaryManualEntry {}}+nonisolated enum DictionaryPronunciationRevisionPolicy {+ /// Pure UI snapshot: no file access, settings writes or background re-encoding.+ static func notice(+ profiles: [PronunciationDictionaryProfile],+ descriptor: ParakeetSpeechModelCatalog.Descriptor,+ entryIDs: Set<UUID>+ ) -> String? {+ guard descriptor.variant == .mini || descriptor.variant == .pico else { return nil }+ let current = Set(profiles.filter {+ $0.modelKey == descriptor.pronunciationModelKey && $0.isEligibleForMatching+ }.map(\.dictionaryEntryID))+ let outdated = profiles.filter {+ entryIDs.contains($0.dictionaryEntryID) && !current.contains($0.dictionaryEntryID)+ && ($0.modelKey == descriptor.modelID || $0.modelKey.hasPrefix(descriptor.modelID + ":sha256:"))+ && $0.modelKey != descriptor.pronunciationModelKey+ }+ let labels = Array(Set(outdated.map(\.label))).sorted()+ guard !labels.isEmpty else { return nil }+ let words = labels.prefix(3).joined(separator: ", ")+ let additional = labels.count > 3 ? " and \(labels.count - 3) more" : ""+ return "Pronunciation recordings for \(words)\(additional) need retraining for the updated \(descriptor.displayName). Your custom words and text corrections remain saved."+ }+}+enum PronunciationProfileEditPolicy {static func shouldDiscardProfile(previousReplacement: String, updatedReplacement: String) -> Bool {previousReplacement.caseInsensitiveCompare(updatedReplacement) != .orderedSamediff --git a/Sources/Fluid/UI/MeetingTranscriptionView.swift b/Sources/Fluid/UI/MeetingTranscriptionView.swiftindex decc9549..6d25c0e7 100644--- a/Sources/Fluid/UI/MeetingTranscriptionView.swift+++ b/Sources/Fluid/UI/MeetingTranscriptionView.swift@@ -146,6 +146,8 @@ struct MeetingTranscriptionView: View {@State private var setupDraft: MeetingTranscriptionSetupDraft@State private var setupDraftBeforeEditing: MeetingTranscriptionSetupDraft+ @State private var pendingBackupSetupRefresh = false+ @State private var cachedSystemDefaultMicrophoneUID: String?@State private var isShowingMeetingSettings: Bool@State private var applications: [MeetingApplicationOption] = []@State private var microphones: [MeetingMicrophoneOption] = []@@ -303,6 +305,13 @@ struct MeetingTranscriptionView: View {Task { await self.refreshSources(requestPermissions: false) }self.regenerateDefaultTitleIfNeeded()}+ .onReceive(NotificationCenter.default.publisher(for: .settingsBackupDidRestore)) { _ in+ self.pendingBackupSetupRefresh = true+ self.applyPendingBackupSetupRefresh()+ }+ .onChange(of: self.canRefreshSetupAfterBackupRestore) { _, canRefresh in+ if canRefresh { self.applyPendingBackupSetupRefresh() }+ }.onChange(of: self.setupDraft.selectedApplicationID) { _, _ inself.regenerateDefaultTitleIfNeeded()}@@ -575,6 +584,7 @@ struct MeetingTranscriptionView: View {if AVCaptureDevice.authorizationStatus(for: .audio) == .authorized {let snapshot = await MeetingCaptureSourceCatalog.microphoneSnapshot()let identities = snapshot.identities+ self.cachedSystemDefaultMicrophoneUID = snapshot.defaultCoreAudioUIDself.microphones = identities.map(MeetingMicrophoneOption.init)self.selectPreferredMicrophone(from: identities, systemDefaultUID: snapshot.defaultCoreAudioUID)} else {@@ -1108,6 +1118,41 @@ struct MeetingTranscriptionView: View {}}+ // Restore updates future setup only; a running meeting and an open editing sheet+ // keep their draft until the existing activity/dismissal events reach a safe point.+ private var canRefreshSetupAfterBackupRestore: Bool {+ self.coordinator.isQuiescent && !self.isStarting && !self.isStopping &&+ !self.isRetrying && !self.isRefreshingSources && !self.isShowingMeetingSettings+ }++ private func applyPendingBackupSetupRefresh() {+ guard self.pendingBackupSetupRefresh, self.canRefreshSetupAfterBackupRestore else { return }+ self.pendingBackupSetupRefresh = false+ var restoredDraft = MeetingTranscriptionSetupDraft(settings: .shared)+ if self.setupDraft.titleWasEdited {+ restoredDraft.title = self.setupDraft.title+ restoredDraft.titleWasEdited = true+ }+ self.setupDraft = restoredDraft+ self.selectPreferredMicrophone(+ from: self.microphones.map(\.identity),+ systemDefaultUID: self.cachedSystemDefaultMicrophoneUID+ )+ self.selectPreferredApplication(from: self.applications.map(\.identity))+ self.regenerateDefaultTitleIfNeeded()+ self.setupDraftBeforeEditing = self.setupDraft+ self.draftMeetingAudioRetentionPolicy = SettingsStore.shared.meetingAudioRetentionPolicy+ }++ private func finishRestoredMeetingSettingsIfPending() -> Bool {+ guard self.pendingBackupSetupRefresh else { return false }+ // A backup imported in another window supersedes this older sheet. Closing+ // it must not write its stale language/mode over the restored preferences.+ self.isShowingMeetingSettings = false+ self.applyPendingBackupSetupRefresh()+ return true+ }+private func openMeetingSettings() {self.setupDraft.autoDetectEnabled = SettingsStore.shared.meetingAutoDetectEnabledself.setupDraft.browserDetectionEnabled = SettingsStore.shared.meetingAutoDetectBrowserEnabled@@ -1127,6 +1172,7 @@ struct MeetingTranscriptionView: View {}private func cancelMeetingSettings() {+ if self.finishRestoredMeetingSettingsIfPending() { return }self.setupDraft = self.setupDraftBeforeEditingself.draftMeetingAudioRetentionPolicy = SettingsStore.shared.meetingAudioRetentionPolicyself.isShowingMeetingSettings = false@@ -1134,6 +1180,7 @@ struct MeetingTranscriptionView: View {}private func saveMeetingSettings() {+ if self.finishRestoredMeetingSettingsIfPending() { return }guard let microphone = self.microphones.first(where: { $0.id == self.setupDraft.selectedMicrophoneID }) else {self.actionErrorMessage = "Choose an available microphone before saving."returndiff --git a/Sources/Fluid/UI/TranscriptionHistoryView.swift b/Sources/Fluid/UI/TranscriptionHistoryView.swiftindex 4bcbc970..2858fd70 100644--- a/Sources/Fluid/UI/TranscriptionHistoryView.swift+++ b/Sources/Fluid/UI/TranscriptionHistoryView.swift@@ -2,6 +2,20 @@ import AppKitimport SwiftUIimport UniformTypeIdentifiers+/// A hidden existing row can be selected from sidebar search even when the list is empty.+nonisolated enum HistorySelectionRevealPolicy {+ static func needsFilterReset(+ requestedID: UUID?,+ selectedID: UUID?,+ allEntries: [TranscriptionHistoryEntry],+ visibleEntries: [TranscriptionHistoryEntry]+ ) -> Bool {+ guard let selectedID, requestedID == selectedID else { return false }+ return !visibleEntries.contains { $0.id == selectedID }+ && allEntries.contains { $0.id == selectedID }+ }+}+struct TranscriptionHistoryView: View {@ObservedObject private var historyStore = TranscriptionHistoryStore.shared@ObservedObject private var settings = SettingsStore.shared@@ -104,7 +118,10 @@ struct TranscriptionHistoryView: View {.frame(minWidth: 400)}}- .onChange(of: self.filteredEntries.map(\.id), initial: true) { _, visibleIDs in+ .onChange(of: self.historyStore.searchSelectionRequest) { _, _ in+ self.revealExternalSelection()+ }+ .onChange(of: self.filteredEntries.map(\.id)) { _, visibleIDs inif let selectedEntryID = self.selectedEntryID, visibleIDs.contains(selectedEntryID) { return }self.selectedEntryID = visibleIDs.first}@@ -119,6 +136,7 @@ struct TranscriptionHistoryView: View {}.onAppear {self.audioAvailabilityRevision = UUID()+ self.revealExternalSelection()if self.selectedEntryID == nil {self.selectedEntryID = self.filteredEntries.first?.id}@@ -212,19 +230,28 @@ struct TranscriptionHistoryView: View {}}- /// Scrolls to a row chosen elsewhere (the sidebar search). A local filter that- /// hides it is cleared first, or the selection would fall back to the first row.+ /// Parent-level handling also runs when no list exists to observe the selection.+ private func revealExternalSelection() {+ guard let request = self.historyStore.searchSelectionRequest else { return }+ defer { self.historyStore.consumeSearchSelectionRequest(request) }+ guard HistorySelectionRevealPolicy.needsFilterReset(+ requestedID: request.entryID,+ selectedID: self.selectedEntryID,+ allEntries: self.historyStore.entries,+ visibleEntries: self.filteredEntries+ ) else { return }+ self.searchQuery = ""+ self.starredOnly = false+ }++ /// The parent clears a hidden selection's filters; scroll after that view update.private func reveal(_ id: UUID?, with proxy: ScrollViewProxy) {guard let id else { return }if !self.filteredEntries.contains(where: { $0.id == id }) {- self.searchQuery = ""- self.starredOnly = false- DispatchQueue.main.async {- proxy.scrollTo(id)- }- return+ DispatchQueue.main.async { proxy.scrollTo(id) }+ } else {+ proxy.scrollTo(id)}- proxy.scrollTo(id)}private func entryRow(_ entry: TranscriptionHistoryEntry) -> some View {diff --git a/Sources/Fluid/UI/WelcomeView.swift b/Sources/Fluid/UI/WelcomeView.swiftindex 0c706714..60808aa5 100644--- a/Sources/Fluid/UI/WelcomeView.swift+++ b/Sources/Fluid/UI/WelcomeView.swift@@ -3,6 +3,28 @@ import AVFoundationimport Combineimport SwiftUI+/// Presentation only: preserve the user's selected model and the language catalog's order.+enum OnboardingModelRecommendation {+ static func defaultRoutes(forLanguageID languageID: String, from availableRoutes: [VoiceEngineLanguageRoute]) -> [VoiceEngineLanguageRoute] {+ guard let first = availableRoutes.first else { return [] }+ guard languageID == "en" else { return [first] }+ if let english = availableRoutes.first(where: { $0.model == .parakeetTDTv2 }),+ let mini = availableRoutes.first(where: { $0.model == .fluidParakeetMini })+ {+ return [english, mini]+ }+ // Mini has the same architecture gate and a newer OS gate. Keep the+ // established cards when either preferred model is unavailable.+ var routes = [first]+ if let builtIn = availableRoutes.first(where: { $0.model == .appleSpeech || $0.model == .appleSpeechAnalyzer }),+ builtIn.id != first.id+ {+ routes.append(builtIn)+ }+ return routes+ }+}+struct WelcomeView: View {@EnvironmentObject var appServices: AppServices@Binding var selectedSidebarItem: SidebarItem?@@ -38,6 +60,7 @@ struct OnboardingFlowView: View {}@ObservedObject private var settings = SettingsStore.shared+ @ObservedObject private var installations = SpeechModelInstallationSnapshot.shared@StateObject private var aiSetup = OnboardingAISetupController.live@Binding var currentStep: Int@@ -93,6 +116,7 @@ struct OnboardingFlowView: View {case primarycase secondarycase destructive+ case update}private struct OnboardingPillButtonConfiguration {@@ -205,36 +229,11 @@ struct OnboardingFlowView: View {return self.selectedLanguageRoutes.first}- private var primaryDisplayedModelRoute: VoiceEngineLanguageRoute? {- self.selectedLanguageRoutes.first- }-private var defaultDisplayedModelRoutes: [VoiceEngineLanguageRoute] {- var routes: [VoiceEngineLanguageRoute] = []- if let primaryDisplayedModelRoute {- routes.append(primaryDisplayedModelRoute)- }- if let builtInRoute = self.defaultBuiltInModelRoute,- !routes.contains(where: { $0.id == builtInRoute.id })- {- routes.append(builtInRoute)- }- return routes- }-- private var defaultBuiltInModelRoute: VoiceEngineLanguageRoute? {- guard self.selectedOnboardingLanguage.id == "en" else {- return nil- }-- return self.selectedLanguageRoutes.first { route in- switch route.model {- case .appleSpeech, .appleSpeechAnalyzer:- return true- default:- return false- }- }+ OnboardingModelRecommendation.defaultRoutes(+ forLanguageID: self.selectedOnboardingLanguage.id,+ from: self.selectedLanguageRoutes+ )}private var otherModelRoutes: [VoiceEngineLanguageRoute] {@@ -275,6 +274,7 @@ struct OnboardingFlowView: View {}return self.preparingModelRouteID != nil|| self.asr.hasActiveModelPreparation+ || self.asr.hasActiveModelDownload|| self.asr.isCancellingModelPreparation|| self.asr.isDownloadingModel|| (self.asr.isLoadingModel && !self.asr.isAsrReady)@@ -356,6 +356,13 @@ struct OnboardingFlowView: View {FluidOnboardingWindowTransparency()}.onAppear {+ self.installations.refresh()+ Task {+ let catalog = CompactSpeechModelReleaseCatalog.shared+ let revision = catalog.revision+ await catalog.refreshIfNeeded()+ if catalog.revision != revision { self.installations.refresh() }+ }self.isOnboardingFlowVisible = trueself.syncOnboardingSelectionFromSettings()self.playLandingWelcomeSoundIfNeeded()@@ -1426,7 +1433,7 @@ struct OnboardingFlowView: View {}private func isOnboardingModelBundledOrInstalled(_ model: SettingsStore.SpeechModel) -> Bool {- model.isInstalled+ self.installations.isInstalled(modelID: model.id)}private func isPreparingOnboardingModel(_ model: SettingsStore.SpeechModel) -> Bool {@@ -1447,7 +1454,7 @@ struct OnboardingFlowView: View {}private func prepareOnboardingRoute(_ route: VoiceEngineLanguageRoute) {- guard !self.asr.isRunning, !self.isModelPreparationInProgress, self.uninstallingModelRouteID == nil else { return }+ guard self.installations.canUseModelActions, !self.asr.isRunning, !self.isModelPreparationInProgress, self.uninstallingModelRouteID == nil else { return }self.modelPreparationTask?.cancel()self.preparingModelRouteID = route.id@@ -1479,11 +1486,15 @@ struct OnboardingFlowView: View {private func cancelOnboardingModelPreparation() {self.modelPreparationTask?.cancel()- self.asr.cancelModelPreparation()+ if self.asr.hasActiveModelDownload {+ self.asr.cancelModelDownload()+ } else {+ self.asr.cancelModelPreparation()+ }}private func uninstallOnboardingRoute(_ route: VoiceEngineLanguageRoute) {- guard !self.asr.isRunning, !self.isModelPreparationInProgress, self.uninstallingModelRouteID == nil else { return }+ guard self.installations.canUseModelActions, !self.asr.isRunning, !self.isModelPreparationInProgress, self.uninstallingModelRouteID == nil else { return }self.uninstallingModelRouteID = route.id@@ -1509,22 +1520,26 @@ struct OnboardingFlowView: View {enablesHover: Bool = true) -> some View {let model = route.model+ let isCompactModel = model == .fluidParakeetMini || model == .fluidParakeetPicolet isSelected = self.isOnboardingRouteSelected(route)let isHovered = enablesHover && self.hoveredModelRouteID == route.idlet isRouteActiveInSettings = self.isRouteSelectedInSettings(route)let isDownloaded = self.isOnboardingModelBundledOrInstalled(model) || (isRouteActiveInSettings && (self.asr.isAsrReady || self.asr.modelsExistOnDisk))- let isPreparing = self.preparingModelRouteID == route.id || (isRouteActiveInSettings && (self.asr.isDownloadingModel || (self.asr.isLoadingModel && !self.asr.isAsrReady)))+ let isPreparing = self.preparingModelRouteID == route.id || self.asr.downloadingModelId == model.id || (isRouteActiveInSettings && (self.asr.isDownloadingModel || (self.asr.isLoadingModel && !self.asr.isAsrReady)))let isReady = self.isOnboardingRouteReady(route)let isUninstalling = self.uninstallingModelRouteID == route.id- let areModelActionsBlocked = self.asr.isRunning || self.uninstallingModelRouteID != nil || self.preparingModelRouteID != nil || isPreparing || self.isModelPreparationInProgress+ let areModelActionsBlocked = !self.installations.canUseModelActions || self.asr.isRunning || self.uninstallingModelRouteID != nil || self.preparingModelRouteID != nil || isPreparing || self.isModelPreparationInProgresslet isBuiltInAppleModel = model == .appleSpeech || model == .appleSpeechAnalyzerlet shape = RoundedRectangle(cornerRadius: 14, style: .continuous)let cardFill = isHovered? Color(red: 0.042, green: 0.052, blue: 0.074): Color(red: 0.030, green: 0.038, blue: 0.056)- return VStack(alignment: .leading, spacing: 10) {+ return VStack(alignment: .leading, spacing: isCompactModel ? self.theme.metrics.spacing.sm : 10) {HStack(alignment: .top, spacing: 10) {+ if model.brandName == "FluidVoice" {+ FluidVoiceBrandIcon(size: 22)+ }Text(self.onboardingModelTitle(for: model)).font(self.theme.typography.sectionTitle).foregroundStyle(.white)@@ -1546,9 +1561,17 @@ struct OnboardingFlowView: View {}.frame(height: 38, alignment: .top)+ if isCompactModel {+ Text(model.languageSupport)+ .font(self.theme.typography.bodySmallStrong)+ .foregroundStyle(Color.white.opacity(0.62))+ }+self.onboardingModelMetadataRow(badgeText: route.badgeText)- self.onboardingModelFeaturePanel(for: model)+ if model.hasPerformanceRatings {+ self.onboardingModelFeaturePanel(for: model)+ }Spacer(minLength: 0)@@ -1567,7 +1590,7 @@ struct OnboardingFlowView: View {Spacer()- Text(model.downloadSize)+ Text(self.installations.latestDescriptors[model.id]?.downloadSize ?? model.downloadSize).font(self.theme.typography.bodySmallStrong).foregroundStyle(.white).lineLimit(1)@@ -1581,11 +1604,11 @@ struct OnboardingFlowView: View {if isPreparing {self.onboardingModelActionButton(id: "\(route.id)-cancel",- title: self.asr.isCancellingModelPreparation ? "Cancelling…" : "Cancel",+ title: self.asr.isCancellingModelPreparation || self.asr.isCancellingModelDownload ? "Cancelling…" : "Cancel",systemImage: "xmark",tone: .secondary,width: 104,- isDisabled: self.asr.isCancellingModelPreparation+ isDisabled: self.asr.isCancellingModelPreparation || self.asr.isCancellingModelDownload) {self.cancelOnboardingModelPreparation()}@@ -1603,29 +1626,51 @@ struct OnboardingFlowView: View {) {self.prepareOnboardingRoute(route)}+ } else if !self.installations.canUseModelActions {+ if self.installations.isChecking {+ HStack(spacing: 6) {+ ProgressView().controlSize(.small)+ Text("Checking downloads…").font(self.theme.typography.bodySmall)+ }+ } else {+ self.onboardingModelActionButton(+ id: "\(route.id)-retry-check",+ title: "Retry check",+ systemImage: "arrow.clockwise",+ tone: .primary,+ width: nil,+ isDisabled: false+ ) { self.installations.refresh() }+ }} else if isDownloaded {+ let hasUpdate = self.installations.updateAvailableIDs.contains(model.id)HStack(spacing: 8) {+ if hasUpdate {+ self.onboardingModelActionButton(+ id: "\(route.id)-update",+ title: "Update",+ systemImage: "arrow.down.circle",+ tone: .update,+ width: 84,+ isDisabled: areModelActionsBlocked+ ) { self.updateOnboardingRoute(route) }+ }self.onboardingModelActionButton(id: "\(route.id)-activate",- title: self.onboardingModelActionButtonTitle(isPreparing: false, isDownloaded: true, isReady: isReady),+ title: hasUpdate && isReady ? "Active" : self.onboardingModelActionButtonTitle(isPreparing: false, isDownloaded: true, isReady: isReady),systemImage: isReady ? "checkmark" : "bolt.fill",- tone: .primary,- width: 124,+ tone: hasUpdate ? .secondary : .primary,+ width: hasUpdate ? 88 : 124,isDisabled: areModelActionsBlocked || isReady- ) {- self.prepareOnboardingRoute(route)- }-+ ) { self.prepareOnboardingRoute(route) }self.onboardingModelActionButton(id: "\(route.id)-uninstall",title: "Delete",systemImage: "trash",tone: .destructive,- width: 124,+ width: hasUpdate ? 72 : 124,isDisabled: areModelActionsBlocked- ) {- self.uninstallOnboardingRoute(route)- }+ ) { self.uninstallOnboardingRoute(route) }}} else {self.onboardingModelActionButton(@@ -1664,7 +1709,7 @@ struct OnboardingFlowView: View {}}.onTapGesture {- guard !areModelActionsBlocked else { return }+ guard !areModelActionsBlocked, !self.isModelPreparationInProgress else { return }self.selectOnboardingRoute(route)}.onHover { isHovered in@@ -1692,13 +1737,14 @@ struct OnboardingFlowView: View {)}.padding(.vertical, 2)+ .help("Relative ratings for comparing models, not measured transcription accuracy.").accessibilityElement(children: .combine).accessibilityLabel("Speed \(Int(model.speedPercent * 100)) percent. Accuracy \(Int(model.accuracyPercent * 100)) percent.")}private func onboardingModelPreparationStatus(isUninstalling: Bool) -> some View {VStack(alignment: .leading, spacing: 7) {- if self.asr.isCancellingModelPreparation {+ if self.asr.isCancellingModelPreparation || self.asr.isCancellingModelDownload {HStack(spacing: 8) {ProgressView().controlSize(.small)@@ -1708,7 +1754,7 @@ struct OnboardingFlowView: View {.font(self.theme.typography.captionStrong).foregroundStyle(Color.white.opacity(0.62))}- } else if self.asr.isDownloadingModel,+ } else if self.asr.isDownloadingModel || self.asr.hasActiveModelDownload,self.asr.modelPreparationPhase == .downloading,let progress = self.asr.downloadProgress{@@ -1857,11 +1903,15 @@ struct OnboardingFlowView: View {onHover: @escaping (Bool) -> Void) -> some View {let shape = Capsule()- let accentColor: Color = configuration.tone == .destructive ? .red : FluidOnboardingLandingColors.blue- let isFilledTone = configuration.tone == .primary || configuration.tone == .destructive+ let accentColor: Color = switch configuration.tone {+ case .destructive: .red+ case .update: .orange+ default: FluidOnboardingLandingColors.blue+ }+ let isFilledTone = configuration.tone != .secondarylet fillColor: Color = {switch configuration.tone {- case .primary, .destructive:+ case .primary, .destructive, .update:return accentColor.opacity(configuration.isEnabled ? 1 : 0.34)case .secondary:return Color.white.opacity(configuration.isEnabled ? (configuration.isHovered ? 0.11 : 0.07) : 0.045)@@ -1869,7 +1919,7 @@ struct OnboardingFlowView: View {}()let borderColor: Color = {switch configuration.tone {- case .primary, .destructive:+ case .primary, .destructive, .update:return Color.white.opacity(configuration.isHovered && configuration.isEnabled ? 0.30 : 0)case .secondary:return configuration.isHovered && configuration.isEnabled ? FluidOnboardingLandingColors.blue.opacity(0.30) : Color.white.opacity(0.07)@@ -1879,7 +1929,7 @@ struct OnboardingFlowView: View {let shadowOpacity: Double = {guard configuration.isEnabled else { return 0 }switch configuration.tone {- case .primary, .destructive:+ case .primary, .destructive, .update:return configuration.isHovered ? 0.56 : 0.26case .secondary:return configuration.isHovered ? 0.08 : 0@@ -1934,7 +1984,9 @@ struct OnboardingFlowView: View {private func onboardingModelTooltip(for route: VoiceEngineLanguageRoute) -> String {let model = route.model- return "\(self.onboardingModelSubtitle(for: model)) - \(model.downloadSize)\n\(model.cardDescription)"+ let downloadSize = self.installations.latestDescriptors[model.id]?.downloadSize ?? model.downloadSize+ let credit = model.parakeetDescriptor.map { "\n\($0.creditLine)" } ?? ""+ return "\(self.onboardingModelSubtitle(for: model)) - \(downloadSize)\n\(model.cardDescription)\(credit)"}private func onboardingModelTitle(for model: SettingsStore.SpeechModel) -> String {@@ -1947,6 +1999,8 @@ struct OnboardingFlowView: View {return "Parakeet v3"case .parakeetTDTv2:return "Parakeet v2"+ case .fluidParakeetMini, .fluidParakeetPico:+ return model.displayNamecase .parakeetRealtime:return "Parakeet Flash"case .cohereTranscribeSixBit:@@ -2212,6 +2266,30 @@ struct OnboardingFlowView: View {}private extension OnboardingFlowView {+ func updateOnboardingRoute(_ route: VoiceEngineLanguageRoute) {+ guard self.installations.canUseModelActions, !self.asr.isRunning,+ self.asr.activeExclusiveActivity == nil, !self.isModelPreparationInProgress,+ self.uninstallingModelRouteID == nil+ else { return }+ self.preparingModelRouteID = route.id+ self.modelPreparationTask = Task { @MainActor in+ defer { self.preparingModelRouteID = nil; self.modelPreparationTask = nil }+ do {+ try await self.asr.downloadModel(route.model, source: .onboarding, updateWeights: true, progressHandler: nil)+ } catch is CancellationError {+ // The retained installation remains available.+ } catch {+ if let failure = error as? ParakeetArchiveDownloader.DownloadError, case .replacementCleanupFailed = failure {+ self.asr.errorTitle = "Model Updated"+ } else {+ self.asr.errorTitle = "Model Update Failed"+ }+ self.asr.errorMessage = error.localizedDescription+ self.asr.showError = true+ }+ }+ }+var aiEnhancementStep: some View {OnboardingAIEnhancementStepView(setup: self.aiSetup,diff --git a/Tests/FluidDictationIntegrationTests/AppSearchServiceTests.swift b/Tests/FluidDictationIntegrationTests/AppSearchServiceTests.swiftindex 6b6f392a..0a152fdf 100644--- a/Tests/FluidDictationIntegrationTests/AppSearchServiceTests.swift+++ b/Tests/FluidDictationIntegrationTests/AppSearchServiceTests.swift@@ -1,5 +1,7 @@+import AppKit@testable import FluidVoice_Debugimport Foundation+import SwiftUIimport XCTest/// The query side of the sidebar search.@@ -60,7 +62,7 @@ final class AppSearchServiceTests: XCTestCase {service.query = "launch at startup"service.query = "accent color"- try await Task.sleep(for: .milliseconds(600))+ try await self.waitUntil { !service.isSearching && !service.groups.isEmpty }let settings = try XCTUnwrap(service.groups.first { $0.kind == .settings })XCTAssertTrue(settings.hits.contains { $0.target == .settings(.accentColor) })@@ -77,7 +79,7 @@ final class AppSearchServiceTests: XCTestCase {let service = AppSearchService(index: SearchIndex(root: FluidZeppelinRoot(root: root)))service.query = "launch at startup"- try await Task.sleep(for: .milliseconds(600))+ try await self.waitUntil { !service.isSearching && !service.groups.isEmpty }XCTAssertFalse(service.groups.isEmpty)service.query = "accent color"@@ -85,6 +87,341 @@ final class AppSearchServiceTests: XCTestCase {XCTAssertTrue(service.groups.isEmpty)}+ private func waitUntil(_ condition: () async -> Bool) async throws {+ let deadline = ContinuousClock.now.advanced(by: .seconds(5))+ while !(await condition()), ContinuousClock.now < deadline {+ try await Task.sleep(for: .milliseconds(10))+ }+ guard await condition() else {+ XCTFail("A bounded app-search condition did not complete")+ throw AppSearchPreparationGate.Failure.unavailable+ }+ }++ private static func queryGroup(_ query: String) -> [AppSearchGroup] {+ [AppSearchGroup(kind: .settings, hits: [AppSearchHit(+ kind: .settings,+ target: .settings(query == "old" ? .launchAtStartup : .accentColor),+ title: query,+ snippet: "",+ date: nil+ )])]+ }++ func testFirstQueryWaitsForPreparationAndShowsPendingState() async throws {+ let gate = AppSearchPreparationGate()+ var queried: [String] = []+ let service = AppSearchService(prepareIndex: { try await gate.wait() }, performSearch: { query in+ queried.append(query)+ return Self.queryGroup(query)+ })+ service.query = "old"+ do {+ try await self.waitUntil { await gate.hasStarted() }+ XCTAssertTrue(service.isSearching)+ XCTAssertTrue(service.groups.isEmpty)+ XCTAssertNil(service.searchError)+ XCTAssertTrue(queried.isEmpty, "A lexical query cannot run before authoritative snapshots are ready")+ await gate.release()+ try await self.waitUntil { !service.isSearching }+ XCTAssertEqual(queried, ["old"])+ XCTAssertEqual(service.groups, Self.queryGroup("old"))+ XCTAssertNil(service.searchError)+ } catch {+ service.query = ""+ await gate.release()+ throw error+ }+ service.query = ""+ }++ func testFailedPreparationShowsRetryableErrorAndDoesNotRunTheQuery() async throws {+ let gate = AppSearchPreparationGate()+ var queried: [String] = []+ let service = AppSearchService(prepareIndex: { try await gate.wait() }, performSearch: { query in+ queried.append(query)+ return Self.queryGroup(query)+ })+ service.query = "new"+ do {+ try await self.waitUntil { await gate.hasStarted() }+ await gate.release(failing: true)+ try await self.waitUntil { !service.isSearching }+ XCTAssertTrue(service.groups.isEmpty)+ XCTAssertNotNil(service.searchError)+ XCTAssertTrue(queried.isEmpty)+ await gate.release(failing: false)+ service.refresh()+ XCTAssertTrue(service.isSearching)+ XCTAssertNil(service.searchError)+ try await self.waitUntil { !service.isSearching }+ XCTAssertEqual(queried, ["new"])+ XCTAssertEqual(service.groups, Self.queryGroup("new"))+ XCTAssertNil(service.searchError)+ } catch {+ service.query = ""+ await gate.release()+ throw error+ }+ service.query = ""+ }++ func testOnlyExplicitRetryReloadsFailedPreparationAndStoppedRetryDoesNothing() async throws {+ let center = NotificationCenter()+ var preparationCalls = 0+ var retryCalls = 0+ var canPrepare = false+ var queried: [String] = []+ let service = AppSearchService(+ prepareIndex: {+ preparationCalls += 1+ if !canPrepare { throw AppSearchPreparationGate.Failure.unavailable }+ },+ retryPreparation: {+ retryCalls += 1+ canPrepare = true+ },+ performSearch: { query in+ queried.append(query)+ return Self.queryGroup(query)+ },+ notificationCenter: center+ )+ defer { service.stop() }+ service.query = "old"+ try await self.waitUntil { !service.isSearching }+ XCTAssertNotNil(service.searchError)+ service.query = "new"+ try await self.waitUntil { !service.isSearching }+ service.refresh()+ try await self.waitUntil { !service.isSearching }+ center.post(name: .parakeetVocabularyDidChange, object: nil)+ await withCheckedContinuation { (continuation: CheckedContinuation<Void, Never>) in+ DispatchQueue.main.async { continuation.resume() }+ }+ try await self.waitUntil { !service.isSearching }+ XCTAssertEqual(preparationCalls, 4)+ XCTAssertEqual(retryCalls, 0, "Typing, refresh, and cache invalidation must not reload source history")+ XCTAssertNotNil(service.searchError)+ XCTAssertTrue(queried.isEmpty)++ service.retry()+ XCTAssertEqual(retryCalls, 1)+ XCTAssertTrue(service.isSearching)+ XCTAssertNil(service.searchError)+ try await self.waitUntil { !service.isSearching }+ XCTAssertEqual(service.groups, Self.queryGroup("new"))+ XCTAssertEqual(queried, ["new"])+ XCTAssertEqual(preparationCalls, 5)+ XCTAssertNil(service.searchError)++ service.stop()+ service.retry()+ service.query = "after stop"+ service.refresh()+ center.post(name: .parakeetVocabularyDidChange, object: nil)+ try await Task.sleep(for: .milliseconds(120))+ XCTAssertEqual(retryCalls, 1)+ XCTAssertEqual(preparationCalls, 5)+ XCTAssertEqual(queried, ["new"])+ XCTAssertTrue(service.groups.isEmpty)+ XCTAssertFalse(service.isSearching)+ XCTAssertNil(service.searchError)+ }++ func testOlderInFlightQueryCannotReplaceNewerResultsWhenItCompletesLate() async throws {+ let gate = AppSearchQueryGate(blockedQueries: ["old"])+ let service = AppSearchService(performSearch: { query in+ await gate.run(query)+ return Self.queryGroup(query)+ })+ service.query = "old"+ do {+ try await self.waitUntil { await gate.calls().contains("old") }+ service.query = "new"+ try await self.waitUntil { !service.isSearching && service.groups == Self.queryGroup("new") }+ await gate.release("old")+ try await self.waitUntil { await gate.finished().contains("old") }+ // The completion is delivered through the real schedule task; give+ // that main-actor continuation a turn before checking non-effects.+ await Task.yield()+ XCTAssertEqual(service.groups, Self.queryGroup("new"))+ XCTAssertFalse(service.isSearching)+ XCTAssertNil(service.searchError)+ } catch {+ service.query = ""+ await gate.release("old")+ throw error+ }+ service.query = ""+ }++ func testClearingQueryWhileSearchIsInFlightCannotRepublishLateResults() async throws {+ let gate = AppSearchQueryGate(blockedQueries: ["old"])+ let service = AppSearchService(performSearch: { query in+ await gate.run(query)+ return Self.queryGroup(query)+ })+ service.query = "old"+ do {+ try await self.waitUntil { await gate.calls().contains("old") }+ service.query = " "+ XCTAssertTrue(service.groups.isEmpty)+ XCTAssertFalse(service.isSearching)+ XCTAssertNil(service.searchError)+ await gate.release("old")+ try await self.waitUntil { await gate.finished().contains("old") }+ await Task.yield()+ XCTAssertTrue(service.groups.isEmpty)+ XCTAssertFalse(service.isSearching)+ XCTAssertNil(service.searchError)+ } catch {+ service.query = ""+ await gate.release("old")+ throw error+ }+ }++ func testStoppingSearchRejectsLateResultsAndAllLaterQueries() async throws {+ let gate = AppSearchQueryGate(blockedQueries: ["old"])+ var preparationCalls = 0+ let service = AppSearchService(prepareIndex: { preparationCalls += 1 }, performSearch: { query in+ await gate.run(query)+ return Self.queryGroup(query)+ })+ service.query = "old"+ do {+ try await self.waitUntil { await gate.calls().contains("old") }+ XCTAssertEqual(preparationCalls, 1)+ service.stop()+ XCTAssertTrue(service.groups.isEmpty)+ XCTAssertFalse(service.isSearching)+ XCTAssertNil(service.searchError)+ await gate.release("old")+ try await self.waitUntil { await gate.finished().contains("old") }+ service.query = "new"+ service.refresh()+ let direct = await service.search("direct after stop")+ XCTAssertTrue(direct.isEmpty)+ // Beyond the real 80 ms debounce, any incorrectly restarted task+ // would reach the runner and be visible in this gate's call list.+ try await Task.sleep(for: .milliseconds(120))+ let calls = await gate.calls()+ XCTAssertEqual(calls, ["old"])+ XCTAssertEqual(preparationCalls, 1)+ XCTAssertTrue(service.groups.isEmpty)+ XCTAssertFalse(service.isSearching)+ XCTAssertNil(service.searchError)+ } catch {+ service.stop()+ await gate.release("old")+ throw error+ }+ }++ private func withVocabularyProbe(failingReads: Set<Int> = [], _ body: (AppSearchService, AppSearchVocabularyProbe, NotificationCenter) async throws -> Void) async throws {+ let directory = FileManager.default.temporaryDirectory.appendingPathComponent("AppSearchVocabularyTests-\(UUID().uuidString)", isDirectory: true)+ let database = FluidZeppelinRoot(root: directory)+ let loader = AppSearchVocabularyProbe(failingReads: failingReads)+ let center = NotificationCenter()+ let service = AppSearchService(index: SearchIndex(root: database), readVocabulary: { try await loader.read() }, notificationCenter: center)+ do {+ try await body(service, loader, center)+ } catch {+ service.stop()+ await loader.releaseAll()+ await database.closeAll()+ try? FileManager.default.removeItem(at: directory)+ throw error+ }+ service.stop()+ await loader.releaseAll()+ await database.closeAll()+ try? FileManager.default.removeItem(at: directory)+ }++ private static func vocabularyTargets(_ groups: [AppSearchGroup]) -> [AppSearchHit.Target] {+ groups.first { $0.kind == .vocabulary }?.hits.map(\.target) ?? []+ }++ func testTransientVocabularyReadFailureRetriesThenCachesSuccessfulLoad() async throws {+ try await self.withVocabularyProbe(failingReads: [0]) { service, loader, _ in+ let term = ParakeetVocabularyStore.VocabularyConfig.Term(text: "fvsearchvocabfixture alpha", weight: 2, aliases: ["fvsearchaliasfixture"])+ await loader.setTerms([term])+ let failed = await service.search("fvsearchvocabfixture")+ XCTAssertTrue(Self.vocabularyTargets(failed).isEmpty)+ let retry = await service.search("fvsearchaliasfixture")+ XCTAssertEqual(Self.vocabularyTargets(retry), [.vocabulary(term.text)])+ let cached = await service.search("fvsearchvocabfixture")+ XCTAssertEqual(Self.vocabularyTargets(cached), [.vocabulary(term.text)])+ let reads = await loader.readCount()+ XCTAssertEqual(reads, 2, "Only a successful read may become the reusable immutable snapshot")+ }+ }++ func testSuccessfulEmptyVocabularyLoadIsCachedUntilAnActualChange() async throws {+ try await self.withVocabularyProbe { service, loader, _ in+ let first = await service.search("fvsearchvocabfixture")+ XCTAssertTrue(Self.vocabularyTargets(first).isEmpty)+ await loader.setTerms([.init(text: "fvsearchvocabfixture unpublished", weight: 2)])+ let cached = await service.search("fvsearchvocabfixture")+ XCTAssertTrue(Self.vocabularyTargets(cached).isEmpty, "Changing the fixture without an event must not trigger disk rereads")+ let reads = await loader.readCount()+ XCTAssertEqual(reads, 1)+ }+ }++ func testVocabularyChangeInvalidatesOnlyTheSuccessfulSearchSnapshot() async throws {+ try await self.withVocabularyProbe { service, loader, center in+ let first = ParakeetVocabularyStore.VocabularyConfig.Term(text: "fvsearchvocabfixture alpha", weight: 2)+ let updated = ParakeetVocabularyStore.VocabularyConfig.Term(text: "fvsearchvocabfixture beta", weight: 2)+ await loader.setTerms([first])+ service.query = "fvsearchvocabfixture"+ try await self.waitUntil { !service.isSearching && Self.vocabularyTargets(service.groups) == [.vocabulary(first.text)] }+ await loader.setTerms([updated])+ // Private center: global vocabulary events also retire ASR models.+ // This fixture must never notify those unrelated production consumers.+ center.post(name: .parakeetVocabularyDidChange, object: nil)+ try await self.waitUntil { !service.isSearching && Self.vocabularyTargets(service.groups) == [.vocabulary(updated.text)] }+ service.refresh()+ try await self.waitUntil { !service.isSearching && Self.vocabularyTargets(service.groups) == [.vocabulary(updated.text)] }+ let reads = await loader.readCount()+ XCTAssertEqual(reads, 2, "One real change invalidates the snapshot once; later keystrokes reuse it")+ }+ }++ func testLateVocabularyLoadCannotReplaceTheSnapshotFromANewerChange() async throws {+ try await self.withVocabularyProbe { service, loader, center in+ let first = ParakeetVocabularyStore.VocabularyConfig.Term(text: "fvsearchvocabfixture stale", weight: 2)+ let updated = ParakeetVocabularyStore.VocabularyConfig.Term(text: "fvsearchvocabfixture latest", weight: 2)+ await loader.setTerms([first])+ await loader.gateRead(0)+ let old = Task { await service.search("fvsearchvocabfixture") }+ do {+ try await self.waitUntil { await loader.readCount() == 1 }+ await loader.setTerms([updated])+ center.post(name: .parakeetVocabularyDidChange, object: nil)+ // The event uses receive(on: .main). This FIFO barrier drains+ // that delivery without a sleep or a global notification.+ await withCheckedContinuation { (continuation: CheckedContinuation<Void, Never>) in+ DispatchQueue.main.async { continuation.resume() }+ }+ let latest = await service.search("fvsearchvocabfixture")+ XCTAssertEqual(Self.vocabularyTargets(latest), [.vocabulary(updated.text)])+ await loader.releaseRead(0)+ _ = await old.value+ let cached = await service.search("fvsearchvocabfixture")+ XCTAssertEqual(Self.vocabularyTargets(cached), [.vocabulary(updated.text)], "The older loader result must not poison the newly cached generation")+ let reads = await loader.readCount()+ XCTAssertEqual(reads, 2)+ } catch {+ await loader.releaseAll()+ _ = await old.value+ throw error+ }+ }+ }+func testFileTranscriptRevealIgnoresOtherSearchDestinations() {let id = UUID()@@ -127,3 +464,187 @@ final class AppSearchServiceTests: XCTestCase {XCTAssertTrue(AppSearchService.matches("cafe", ["café"]))}}++private actor AppSearchPreparationGate {+ enum Failure: Error { case unavailable }+ private var started = false+ private var released = false+ private var failing = false+ private var waiters: [CheckedContinuation<Void, Never>] = []++ func hasStarted() -> Bool { self.started }++ func wait() async throws {+ self.started = true+ if !self.released { await withCheckedContinuation { self.waiters.append($0) } }+ if self.failing { throw Failure.unavailable }+ }++ func release(failing: Bool = false) {+ self.failing = failing+ self.released = true+ let waiters = self.waiters+ self.waiters.removeAll()+ for waiter in waiters {+ waiter.resume()+ }+ }+}++private actor AppSearchQueryGate {+ private let blockedQueries: Set<String>+ private var released: Set<String> = []+ private var entered: [String] = []+ private var completed: [String] = []+ private var waiters: [String: CheckedContinuation<Void, Never>] = [:]++ init(blockedQueries: Set<String>) { self.blockedQueries = blockedQueries }+ func calls() -> [String] { self.entered }+ func finished() -> [String] { self.completed }++ func run(_ query: String) async {+ self.entered.append(query)+ if self.blockedQueries.contains(query), !self.released.contains(query) {+ await withCheckedContinuation { self.waiters[query] = $0 }+ }+ self.completed.append(query)+ }++ func release(_ query: String) {+ self.released.insert(query)+ self.waiters.removeValue(forKey: query)?.resume()+ }+}++private actor AppSearchVocabularyProbe {+ private var terms: [ParakeetVocabularyStore.VocabularyConfig.Term] = []+ private var reads = 0+ private let failingReads: Set<Int>+ private var gatedReads: Set<Int> = []+ private var waiters: [Int: CheckedContinuation<Void, Never>] = [:]++ init(failingReads: Set<Int> = []) { self.failingReads = failingReads }+ func setTerms(_ terms: [ParakeetVocabularyStore.VocabularyConfig.Term]) { self.terms = terms }+ func readCount() -> Int { self.reads }+ func gateRead(_ number: Int) { self.gatedReads.insert(number) }++ func read() async throws -> [ParakeetVocabularyStore.VocabularyConfig.Term] {+ let number = self.reads+ self.reads += 1+ let snapshot = self.terms+ if self.gatedReads.contains(number) { await withCheckedContinuation { self.waiters[number] = $0 } }+ if self.failingReads.contains(number) { throw AppSearchPreparationGate.Failure.unavailable }+ return snapshot+ }++ func releaseRead(_ number: Int) { self.waiters.removeValue(forKey: number)?.resume() }+ func releaseAll() {+ self.gatedReads.removeAll()+ let waiters = self.waiters.values+ self.waiters.removeAll()+ for waiter in waiters {+ waiter.resume()+ }+ }+}++extension AppSearchServiceTests {+ /// App-hosted rendering proof only. No installed-app interaction, preference+ /// or history writes, model preparation, global events, or microphone use.+ func testOptInNativeSearchSidebarStatesAtCompactWidth() async throws {+ guard let path = ProcessInfo.processInfo.environment["FLUIDVOICE_SEARCH_UI_PROOF"], !path.isEmpty else {+ throw XCTSkip("Supply an external output directory for the native search sidebar proof")+ }+ let output = URL(fileURLWithPath: path, isDirectory: true).standardizedFileURL.resolvingSymlinksInPath()+ let repository = URL(fileURLWithPath: #filePath).deletingLastPathComponent().deletingLastPathComponent().deletingLastPathComponent().resolvingSymlinksInPath()+ guard output.path != repository.path, !output.path.hasPrefix(repository.path + "/") else {+ XCTFail("Native proof images must be saved outside the repository")+ throw CocoaError(.fileWriteNoPermission)+ }+ try FileManager.default.createDirectory(at: output, withIntermediateDirectories: true)+ let privateDirectory = FileManager.default.temporaryDirectory.appendingPathComponent("SearchUIProof-\(UUID().uuidString)", isDirectory: true)+ let database = FluidZeppelinRoot(root: privateDirectory)+ let index = SearchIndex(root: database)+ let center = NotificationCenter()+ let gate = AppSearchPreparationGate()+ let loading = AppSearchService(index: index, prepareIndex: { try await gate.wait() }, performSearch: { _ in [] }, notificationCenter: center)+ let error = AppSearchService(index: index, prepareIndex: { throw AppSearchPreparationGate.Failure.unavailable }, performSearch: { _ in [] }, notificationCenter: center)+ let empty = AppSearchService(index: index, performSearch: { _ in [] }, notificationCenter: center)+ let results = AppSearchService(index: index, performSearch: { _ in Self.nativeProofGroups }, notificationCenter: center)+ let services = [loading, error, empty, results]+ do {+ for service in services {+ service.query = "meeting"+ }+ try await self.waitUntil { await gate.hasStarted() }+ try await self.waitUntil { !error.isSearching && !empty.isSearching && !results.isSearching }+ XCTAssertTrue(loading.isSearching)+ XCTAssertNotNil(error.searchError)+ XCTAssertTrue(empty.groups.isEmpty)+ XCTAssertEqual(results.groups, Self.nativeProofGroups)+ let states = [("searching", loading), ("preparation-error", error), ("empty", empty), ("results", results)]+ for scheme in [ColorScheme.dark, .light] {+ let appearance = scheme == .dark ? "dark" : "light"+ for (name, service) in states {+ try await self.captureNativeSearchProof(service, scheme: scheme, destination: output.appendingPathComponent("search-\(name)-\(appearance).png"))+ }+ }+ } catch {+ for service in services {+ service.stop()+ }+ await gate.release()+ await database.closeAll()+ try? FileManager.default.removeItem(at: privateDirectory)+ throw error+ }+ for service in services {+ service.stop()+ }+ await gate.release()+ await database.closeAll()+ try? FileManager.default.removeItem(at: privateDirectory)+ print("Native search sidebar proof: \(output.path) (app-hosted fixtures, 260px, dark/light)")+ }++ private static var nativeProofGroups: [AppSearchGroup] {+ let histories = (1...8).map { number in+ let id = UUID(uuid: (0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, UInt8(number)))+ return AppSearchHit(kind: .history, target: .history(id), title: "Meeting notes \(number)", snippet: "Reviewed the project update and the next steps for the team.", date: nil)+ }+ let settings = AppSearchHit(kind: .settings, target: .settings(.accentColor), title: "Accent color", snippet: "Choose the appearance of FluidVoice.", date: nil)+ return [AppSearchGroup(kind: .history, hits: histories), AppSearchGroup(kind: .settings, hits: [settings])]+ }++ private func captureNativeSearchProof(_ service: AppSearchService, scheme: ColorScheme, destination: URL) async throws {+ let size = NSSize(width: 260, height: 520)+ let theme = AppTheme.adaptive(accent: FluidBrandColors.blue, colorScheme: scheme)+ let content = AppSearchResultsView(service: service, cursor: .constant(nil), expanded: .constant([]), open: { _ in })+ .frame(width: size.width, height: size.height)+ .appTheme(theme)+ .environment(\.colorScheme, scheme)+ let host = NSHostingView(rootView: content)+ host.frame = NSRect(origin: .zero, size: size)+ let window = NSWindow(contentRect: host.frame, styleMask: [.titled], backing: .buffered, defer: false)+ window.isReleasedWhenClosed = false+ window.appearance = NSAppearance(named: scheme == .dark ? .darkAqua : .aqua)+ window.title = "Search sidebar proof"+ window.contentView = host+ window.orderFront(nil)+ defer {+ window.orderOut(nil)+ window.contentView = nil+ window.close()+ }+ host.layoutSubtreeIfNeeded()+ try await Task.sleep(for: .milliseconds(160))+ host.layoutSubtreeIfNeeded()+ host.displayIfNeeded()+ let bitmap = try XCTUnwrap(host.bitmapImageRepForCachingDisplay(in: host.bounds))+ host.cacheDisplay(in: host.bounds, to: bitmap)+ let png = try XCTUnwrap(bitmap.representation(using: .png, properties: [:]))+ XCTAssertEqual(host.bounds.width, 260)+ XCTAssertGreaterThan(png.count, 100)+ try png.write(to: destination)+ }+}diff --git a/Tests/FluidDictationIntegrationTests/CompactSpeechModelArchiveTransportTests.swift b/Tests/FluidDictationIntegrationTests/CompactSpeechModelArchiveTransportTests.swiftnew file mode 100644index 00000000..a825daa0--- /dev/null+++ b/Tests/FluidDictationIntegrationTests/CompactSpeechModelArchiveTransportTests.swift@@ -0,0 +1,368 @@+import CryptoKit+import Darwin+@testable import FluidVoice_Debug+import Foundation+import XCTest++final nonisolated class CompactSpeechModelArchiveTransportTests: XCTestCase {+ func testRangesAssembleOwnedArchiveAndPreserveSiblings() async throws {+ let fixture = try Fixture()+ defer { fixture.cleanup() }+ let recorder = Recorder()+ let (ready, response) = try await fixture.download { request, maximum, progress in+ recorder.add(request.value(forHTTPHeaderField: "Range") ?? "")+ XCTAssertEqual(request.value(forHTTPHeaderField: "Accept-Encoding"), "identity")+ XCTAssertLessThanOrEqual(maximum, 4)+ return try fixture.chunk(request, progress: progress)+ }+ defer { try? FileManager.default.removeItem(at: ready) }+ XCTAssertEqual(recorder.values, ["bytes=0-3", "bytes=4-7", "bytes=8-9"])+ XCTAssertEqual(try Data(contentsOf: ready), fixture.payload)+ XCTAssertEqual((response as? HTTPURLResponse)?.statusCode, 200)+ XCTAssertEqual(response.expectedContentLength, 10)+ XCTAssertFalse(FileManager.default.fileExists(atPath: fixture.partial.path))+ XCTAssertEqual(try String(contentsOf: fixture.marker, encoding: .utf8), fixture.descriptor.archiveSHA256)+ try fixture.assertSiblings()+ }++ func testFailureResumesOnlyCompleteRanges() async throws {+ let fixture = try Fixture()+ defer { fixture.cleanup() }+ do {+ _ = try await fixture.download { request, _, progress in+ if request.value(forHTTPHeaderField: "Range") == "bytes=4-7" { throw ProbeFailure.injected }+ return try fixture.chunk(request, progress: progress)+ }+ XCTFail("Expected interrupted transfer")+ } catch { XCTAssertTrue(error is ProbeFailure) }+ XCTAssertEqual(try Data(contentsOf: fixture.partial), fixture.payload.prefix(4))+ let recorder = Recorder()+ let (ready, _) = try await fixture.download { request, _, progress in+ recorder.add(request.value(forHTTPHeaderField: "Range") ?? "")+ return try fixture.chunk(request, progress: progress)+ }+ defer { try? FileManager.default.removeItem(at: ready) }+ XCTAssertEqual(recorder.values, ["bytes=4-7", "bytes=8-9"])+ XCTAssertEqual(try Data(contentsOf: ready), fixture.payload)+ try fixture.assertSiblings()+ }++ func testCancellationJoinsTransportAndPreservesCompletedRange() async throws {+ let fixture = try Fixture()+ defer { fixture.cleanup() }+ let (started, continuation) = AsyncStream<Void>.makeStream()+ let cleanup = Recorder()+ let task = Task {+ try await fixture.download { request, _, progress in+ if request.value(forHTTPHeaderField: "Range") == "bytes=4-7" {+ let (chunk, _) = try fixture.chunk(request, progress: progress)+ continuation.yield(())+ continuation.finish()+ do { try await Task.sleep(for: .seconds(60)) } catch {+ try FileManager.default.removeItem(at: chunk)+ cleanup.add("joined")+ throw error+ }+ throw ProbeFailure.injected+ }+ return try fixture.chunk(request, progress: progress)+ }+ }+ for await _ in started {+ break+ }+ task.cancel()+ do { _ = try await task.value; XCTFail("Expected cancellation") } catch { XCTAssertTrue(error is CancellationError) }+ XCTAssertEqual(cleanup.values, ["joined"])+ XCTAssertEqual(try Data(contentsOf: fixture.partial), fixture.payload.prefix(4))+ XCTAssertFalse(try FileManager.default.contentsOfDirectory(atPath: fixture.base.path).contains { $0.hasPrefix("chunk-") })+ try fixture.assertSiblings()+ }++ func testCanceledReturnedChunkIsDeletedWithoutAppendingIt() async throws {+ let fixture = try Fixture()+ defer { fixture.cleanup() }+ do {+ _ = try await fixture.download { request, _, progress in+ let result = try fixture.chunk(request, progress: progress)+ withUnsafeCurrentTask { $0?.cancel() }+ return result+ }+ XCTFail("Expected cancellation")+ } catch { XCTAssertTrue(error is CancellationError) }+ XCTAssertEqual(try Data(contentsOf: fixture.partial).count, 0)+ XCTAssertFalse(try FileManager.default.contentsOfDirectory(atPath: fixture.base.path).contains { $0.hasPrefix("chunk-") })+ try fixture.assertSiblings()+ }++ func testBadStatusRangeSizeEncodingAndRedirectCannotAdvancePartial() async throws {+ for defect in Defect.allCases {+ let fixture = try Fixture()+ defer { fixture.cleanup() }+ do {+ _ = try await fixture.download { request, _, progress in try fixture.chunk(request, progress: progress, defect: defect) }+ XCTFail("Invalid \(defect) must fail")+ } catch { XCTAssertEqual(error as? CompactSpeechModelArchiveTransport.Failure, .invalidRange) }+ XCTAssertEqual(try Data(contentsOf: fixture.partial).count, 0)+ XCTAssertFalse(try FileManager.default.contentsOfDirectory(atPath: fixture.base.path).contains { $0.hasPrefix("chunk-") })+ try fixture.assertSiblings()+ }+ }++ func testNewReleaseDiscardsOnlyItsOwnOldPartial() async throws {+ let fixture = try Fixture()+ defer { fixture.cleanup() }+ try fixture.seedPartial(fixture.payload.prefix(4), marker: XCTUnwrap(fixture.descriptor.archiveSHA256))+ let replacement = Data("ABCDEFGHIJ".utf8)+ let descriptor = fixture.descriptor.replacingArchive(url: fixture.descriptor.archiveURL, sha256: Fixture.sha256(replacement), byteCount: Int64(replacement.count))+ let recorder = Recorder()+ let (ready, _) = try await CompactSpeechModelArchiveTransport.download(+ descriptor: descriptor,+ in: fixture.models,+ progress: { _, _ in },+ transport: { request, _, progress in+ recorder.add(request.value(forHTTPHeaderField: "Range") ?? "")+ return try fixture.chunk(request, progress: progress, payload: replacement)+ },+ chunkBytes: 4+ )+ defer { try? FileManager.default.removeItem(at: ready) }+ XCTAssertEqual(recorder.values.first, "bytes=0-3")+ XCTAssertEqual(try Data(contentsOf: ready), replacement)+ XCTAssertEqual(try String(contentsOf: fixture.marker, encoding: .utf8), descriptor.archiveSHA256)+ try fixture.assertSiblings()+ }++ func testMalformedMarkerOversizedAndCrashPartialRecoverOnRetry() async throws {+ for corruption in 0..<4 {+ let fixture = try Fixture()+ defer { fixture.cleanup() }+ let hash = try XCTUnwrap(fixture.descriptor.archiveSHA256)+ let marker = corruption == 0 ? "broken" : corruption == 1 ? String(repeating: "z", count: 64) : hash+ let bytes = corruption == 2 ? Data(repeating: 0, count: 11) : fixture.payload.prefix(corruption == 3 ? 6 : 4)+ try fixture.seedPartial(bytes, marker: marker)+ let recorder = Recorder()+ let (ready, _) = try await fixture.download { request, _, progress in+ recorder.add(request.value(forHTTPHeaderField: "Range") ?? "")+ return try fixture.chunk(request, progress: progress)+ }+ defer { try? FileManager.default.removeItem(at: ready) }+ XCTAssertEqual(recorder.values.first, corruption == 3 ? "bytes=4-7" : "bytes=0-3")+ XCTAssertEqual(try Data(contentsOf: ready), fixture.payload)+ try fixture.assertSiblings()+ }+ }++ func testSamePartialClaimRejectsConcurrentDownloadWithoutNetwork() async throws {+ let fixture = try Fixture()+ defer { fixture.cleanup() }+ let (started, continuation) = AsyncStream<Void>.makeStream()+ let first = Task {+ try await fixture.download { _, _, _ in+ continuation.yield(())+ continuation.finish()+ try await Task.sleep(for: .seconds(60))+ throw ProbeFailure.injected+ }+ }+ for await _ in started {+ break+ }+ do {+ _ = try await fixture.download { _, _, _ in XCTFail("A competing claim must fail before network"); throw ProbeFailure.injected }+ XCTFail("Expected another-process claim failure")+ } catch { XCTAssertEqual(error as? CompactSpeechModelArchiveTransport.Failure, .alreadyDownloading) }+ first.cancel()+ do { _ = try await first.value; XCTFail("Expected cancellation") } catch { XCTAssertTrue(error is CancellationError) }+ let (ready, _) = try await fixture.download { request, _, progress in try fixture.chunk(request, progress: progress) }+ defer { try? FileManager.default.removeItem(at: ready) }+ XCTAssertEqual(try Data(contentsOf: ready), fixture.payload)+ try fixture.assertSiblings()+ }++ func testPartialMarkerAndClaimLinksCannotMutateExternalFiles() async throws {+ for name in ["archive.partial", "release.sha256", "claim.lock"] {+ for hardLink in [false, true] {+ let fixture = try Fixture()+ defer { fixture.cleanup() }+ try fixture.seedPartial(Data(), marker: XCTUnwrap(fixture.descriptor.archiveSHA256))+ let external = fixture.base.appendingPathComponent("external")+ let contents = Data(String(repeating: "f", count: 64).utf8)+ try contents.write(to: external)+ let link = fixture.partial.deletingLastPathComponent().appendingPathComponent(name)+ if FileManager.default.fileExists(atPath: link.path) { try FileManager.default.removeItem(at: link) }+ if hardLink { try FileManager.default.linkItem(at: external, to: link) } else { try FileManager.default.createSymbolicLink(at: link, withDestinationURL: external) }+ do {+ _ = try await fixture.download { _, _, _ in XCTFail("Unsafe retained files must fail before network"); throw ProbeFailure.injected }+ XCTFail("Expected unsafe link rejection")+ } catch let error as CompactSpeechModelArchiveTransport.Failure {+ guard case let .unsafePartial(url) = error else { return XCTFail("Expected unsafePartial, got \(error)") }+ XCTAssertEqual(url, link)+ XCTAssertTrue(error.localizedDescription.contains(link.path))+ }+ XCTAssertEqual(try Data(contentsOf: external), contents)+ try fixture.assertSiblings()+ }+ }+ }++ func testCompletedArchiveOwnershipPreventsChecksumFailureResume() async throws {+ try await self.assertChecksumFailureRetry(seedCorruptPrefix: false)+ }++ func testDamagedAlignedRetainedPrefixCannotSurviveChecksumFailureRetry() async throws {+ try await self.assertChecksumFailureRetry(seedCorruptPrefix: true)+ }++ private func assertChecksumFailureRetry(seedCorruptPrefix: Bool) async throws {+ let fixture = try Fixture()+ defer { fixture.cleanup() }+ let corrupted = Data("XXXXXXXXXX".utf8)+ if seedCorruptPrefix {+ try fixture.seedPartial(corrupted.prefix(4), marker: XCTUnwrap(fixture.descriptor.archiveSHA256))+ }+ let (ready, _) = try await fixture.download { request, _, progress in+ try fixture.chunk(request, progress: progress, payload: seedCorruptPrefix ? fixture.payload : corrupted)+ }+ XCTAssertNotEqual(try Fixture.sha256(Data(contentsOf: ready)), fixture.descriptor.archiveSHA256)+ // The outer installer's checksum failure deletes only this uniquely owned complete file.+ try FileManager.default.removeItem(at: ready)+ XCTAssertFalse(FileManager.default.fileExists(atPath: fixture.partial.path))+ let recorder = Recorder()+ let (retry, _) = try await fixture.download { request, _, progress in+ recorder.add(request.value(forHTTPHeaderField: "Range") ?? "")+ return try fixture.chunk(request, progress: progress)+ }+ defer { try? FileManager.default.removeItem(at: retry) }+ XCTAssertEqual(recorder.values.first, "bytes=0-3")+ XCTAssertEqual(try Data(contentsOf: retry), fixture.payload)+ try fixture.assertSiblings()+ }++ func testNextAttemptRemovesDeadProcessHandoffAndPreservesActiveAndUnknownFiles() async throws {+ let fixture = try Fixture()+ defer { fixture.cleanup() }+ try fixture.seedPartial(Data(), marker: XCTUnwrap(fixture.descriptor.archiveSHA256))+ let directory = fixture.partial.deletingLastPathComponent()+ let deadOwner = Int32.max+ XCTAssertEqual(kill(deadOwner, 0), -1)+ XCTAssertEqual(errno, ESRCH)+ let abandoned = directory.appendingPathComponent("ready-\(deadOwner)-\(UUID().uuidString).tar")+ let active = directory.appendingPathComponent("ready-\(getpid())-\(UUID().uuidString).tar")+ let unknown = directory.appendingPathComponent("ready-\(deadOwner)-not-a-uuid.tar")+ for file in [abandoned, active, unknown] { try fixture.payload.write(to: file) }+ let (ready, _) = try await fixture.download { request, _, progress in try fixture.chunk(request, progress: progress) }+ XCTAssertEqual(ready.deletingLastPathComponent(), directory)+ XCTAssertTrue(ready.lastPathComponent.hasPrefix("ready-\(getpid())-"))+ XCTAssertFalse(FileManager.default.fileExists(atPath: abandoned.path))+ XCTAssertEqual(try Data(contentsOf: active), fixture.payload)+ XCTAssertEqual(try Data(contentsOf: unknown), fixture.payload)+ XCTAssertEqual(try Data(contentsOf: ready), fixture.payload)+ try fixture.assertSiblings()+ }++ func testAbandonedHandoffLinksAndDirectoriesCannotDeleteExternalFiles() async throws {+ let fixture = try Fixture()+ defer { fixture.cleanup() }+ try fixture.seedPartial(Data(), marker: XCTUnwrap(fixture.descriptor.archiveSHA256))+ let directory = fixture.partial.deletingLastPathComponent()+ let external = fixture.base.appendingPathComponent("external-ready")+ try fixture.payload.write(to: external)+ let symlink = directory.appendingPathComponent("ready-\(Int32.max)-\(UUID().uuidString).tar")+ let hardlink = directory.appendingPathComponent("ready-\(Int32.max)-\(UUID().uuidString).tar")+ let folder = directory.appendingPathComponent("ready-\(Int32.max)-\(UUID().uuidString).tar")+ try FileManager.default.createSymbolicLink(at: symlink, withDestinationURL: external)+ try FileManager.default.linkItem(at: external, to: hardlink)+ try FileManager.default.createDirectory(at: folder, withIntermediateDirectories: false)+ let (ready, _) = try await fixture.download { request, _, progress in try fixture.chunk(request, progress: progress) }+ XCTAssertEqual(try Data(contentsOf: ready), fixture.payload)+ XCTAssertEqual(try Data(contentsOf: external), fixture.payload)+ for file in [symlink, hardlink, folder] { XCTAssertTrue(FileManager.default.fileExists(atPath: file.path)) }+ try fixture.assertSiblings()+ }++ func testAbandonedHandoffCleanupIsBoundedPerAttempt() async throws {+ let fixture = try Fixture()+ defer { fixture.cleanup() }+ try fixture.seedPartial(Data(), marker: XCTUnwrap(fixture.descriptor.archiveSHA256))+ let directory = fixture.partial.deletingLastPathComponent()+ for _ in 0..<160 {+ let file = directory.appendingPathComponent("ready-\(Int32.max)-\(UUID().uuidString).tar")+ try fixture.payload.write(to: file)+ }+ _ = try await fixture.download { request, _, progress in try fixture.chunk(request, progress: progress) }+ let remaining = try FileManager.default.contentsOfDirectory(atPath: directory.path).filter { $0.hasPrefix("ready-\(Int32.max)-") }+ XCTAssertGreaterThanOrEqual(remaining.count, 160 - 128)+ XCTAssertLessThan(remaining.count, 160)+ try fixture.assertSiblings()+ }++ private enum ProbeFailure: Error { case injected }+ private enum Defect: CaseIterable, Equatable { case status, range, size, encoding, redirect }++ private final class Recorder: @unchecked Sendable {+ private let lock = NSLock()+ private var storage: [String] = []+ var values: [String] { self.lock.withLock { self.storage } }+ func add(_ value: String) { self.lock.withLock { self.storage.append(value) } }+ }++ private struct Fixture: Sendable {+ let base: URL+ let models: URL+ let descriptor: ParakeetSpeechModelCatalog.Descriptor+ let payload = Data("0123456789".utf8)+ var partial: URL { self.models.appendingPathComponent(".compact-downloads/\(self.descriptor.folderName)/archive.partial") }+ var marker: URL { self.partial.deletingLastPathComponent().appendingPathComponent("release.sha256") }++ init() throws {+ self.base = FileManager.default.temporaryDirectory.appendingPathComponent("FVCompactTransport-\(UUID().uuidString)")+ self.models = self.base.appendingPathComponent("models")+ try FileManager.default.createDirectory(at: self.models, withIntermediateDirectories: true)+ let payload = Data("0123456789".utf8)+ self.descriptor = ParakeetSpeechModelCatalog.mini.replacingArchive(url: ParakeetSpeechModelCatalog.mini.archiveURL, sha256: Self.sha256(payload), byteCount: Int64(payload.count))+ try Data("installed-old-weights".utf8).write(to: self.models.appendingPathComponent("preserved-installed"))+ let sibling = self.models.appendingPathComponent(".compact-downloads/\(ParakeetSpeechModelCatalog.pico.folderName)")+ try FileManager.default.createDirectory(at: sibling, withIntermediateDirectories: true)+ try Data("other-model-partial".utf8).write(to: sibling.appendingPathComponent("archive.partial"))+ }++ func cleanup() { try? FileManager.default.removeItem(at: self.base) }+ func download(_ transport: @escaping CompactSpeechModelArchiveTransport.ChunkTransport) async throws -> (URL, URLResponse) {+ try await CompactSpeechModelArchiveTransport.download(descriptor: self.descriptor, in: self.models, progress: { _, _ in }, transport: transport, chunkBytes: 4)+ }++ func chunk(_ request: URLRequest, progress: @Sendable (Int64) -> Void, payload: Data? = nil, defect: Defect? = nil) throws -> (URL, URLResponse) {+ let payload = payload ?? self.payload+ let range = try XCTUnwrap(request.value(forHTTPHeaderField: "Range"))+ let bounds = range.dropFirst("bytes=".count).split(separator: "-")+ let start = try XCTUnwrap(Int(bounds[0]))+ let end = try XCTUnwrap(Int(bounds[1]))+ let file = self.base.appendingPathComponent("chunk-\(UUID().uuidString)")+ let contents = defect == .size ? Data([0]) : payload.subdata(in: start..<(end + 1))+ try contents.write(to: file)+ progress(Int64(contents.count))+ let url = defect == .redirect ? URL(string: "https://elsewhere.example/archive.tar") : request.url+ let response = try XCTUnwrap(HTTPURLResponse(url: XCTUnwrap(url), statusCode: defect == .status ? 200 : 206, httpVersion: "HTTP/1.1", headerFields: [+ "Content-Range": defect == .range ? "bytes 1-4/99" : "bytes \(start)-\(end)/\(payload.count)",+ "Content-Length": String(contents.count),+ "Content-Encoding": defect == .encoding ? "gzip" : "identity",+ ]))+ return (file, response)+ }++ func seedPartial(_ data: Data, marker: String) throws {+ try FileManager.default.createDirectory(at: self.partial.deletingLastPathComponent(), withIntermediateDirectories: true)+ try data.write(to: self.partial)+ try Data(marker.utf8).write(to: self.marker)+ }++ func assertSiblings() throws {+ XCTAssertEqual(try String(contentsOf: self.models.appendingPathComponent("preserved-installed"), encoding: .utf8), "installed-old-weights")+ let sibling = self.models.appendingPathComponent(".compact-downloads/\(ParakeetSpeechModelCatalog.pico.folderName)/archive.partial")+ XCTAssertEqual(try String(contentsOf: sibling, encoding: .utf8), "other-model-partial")+ }++ static func sha256(_ data: Data) -> String { SHA256.hash(data: data).map { String(format: "%02x", $0) }.joined() }+ }+}diff --git a/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/feeds/bad-entry-other-platform.json b/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/feeds/bad-entry-other-platform.jsonnew file mode 100644index 00000000..1e5e5fad--- /dev/null+++ b/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/feeds/bad-entry-other-platform.json@@ -0,0 +1 @@+{"payload": "ewogInNjaGVtYSI6IDEsCiAic2VxdWVuY2UiOiA3LAogIm1vZGVscyI6IHsKICAibWluaSI6IHsKICAgImlvcyI6IFsKICAgIHsKICAgICAicmVsZWFzZSI6ICIxLjIuMCIsCiAgICAgInVybCI6ICJodHRwczovL21vZGVscy5mbHVpZHZvaWNlLmFwcC9wYXJha2VldC9mbHVpZC1taW5pLzEuMi4wL2ZsdWlkLXBhcmFrZWV0LW1pbmktY29yZW1sLnRhciIsCiAgICAgImJ5dGVzIjogMjU0MTM2MzIwLAogICAgICJzaGEyNTYiOiAiYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYSIsCiAgICAgIm1hbmlmZXN0U0hBMjU2IjogImJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmIiLAogICAgICJmb3JtYXQiOiAxLAogICAgICJtaW5CdWlsZCI6IDEwCiAgICB9CiAgIF0sCiAgICJtYWNvcyI6IFtdCiAgfSwKICAicGljbyI6IHsKICAgImlvcyI6IFtdLAogICAibWFjb3MiOiBbCiAgICB7CiAgICAgInJlbGVhc2UiOiAiMS4yLjAiLAogICAgICJ1cmwiOiAiaHR0cHM6Ly9tb2RlbHMuZmx1aWR2b2ljZS5hcHAvcGFyYWtlZXQvZmx1aWQtbWluaS8xLjIuMC9mbHVpZC1wYXJha2VldC1taW5pLWNvcmVtbC50YXIiLAogICAgICJieXRlcyI6IDI1NDEzNjMyMCwKICAgICAic2hhMjU2IjogInNob3J0IiwKICAgICAibWFuaWZlc3RTSEEyNTYiOiAiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYiIsCiAgICAgImZvcm1hdCI6IDEsCiAgICAgIm1pbkJ1aWxkIjogMTAKICAgIH0KICAgXQogIH0KIH0KfQ==", "signature": "aq9l9PjeNIgM5AebMp8uJBnt407lavyYLxfb+CxfU0nry+haQ3yTvFcANI+yY/AE0y2Iwyp8APYUg+PrCUAiCA=="}\ No newline at end of filediff --git a/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/feeds/bad-signature.json b/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/feeds/bad-signature.jsonnew file mode 100644index 00000000..7aeced7e--- /dev/null+++ b/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/feeds/bad-signature.json@@ -0,0 +1 @@+{"payload": "ewogInNjaGVtYSI6IDEsCiAic2VxdWVuY2UiOiA3LAogIm1vZGVscyI6IHsKICAibWluaSI6IHsKICAgImlvcyI6IFsKICAgIHsKICAgICAicmVsZWFzZSI6ICIxLjIuMCIsCiAgICAgInVybCI6ICJodHRwczovL21vZGVscy5mbHVpZHZvaWNlLmFwcC9wYXJha2VldC9mbHVpZC1taW5pLzEuMi4wL2ZsdWlkLXBhcmFrZWV0LW1pbmktY29yZW1sLnRhciIsCiAgICAgImJ5dGVzIjogMjU0MTM2MzIwLAogICAgICJzaGEyNTYiOiAiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYiIsCiAgICAgIm1hbmlmZXN0U0hBMjU2IjogImJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmIiLAogICAgICJmb3JtYXQiOiAxLAogICAgICJtaW5CdWlsZCI6IDEwCiAgICB9CiAgIF0sCiAgICJtYWNvcyI6IFtdCiAgfSwKICAicGljbyI6IHsKICAgImlvcyI6IFtdLAogICAibWFjb3MiOiBbXQogIH0KIH0KfQ==", "signature": "zxFEaNeNNWXIOLT0Rp1a/T0z7D21WwHaJGpcXw1boPhSI5gm5HtS4Ax195LB0fj+0i+B6T0sb9tUNOLFM+AuCA=="}\ No newline at end of filediff --git a/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/feeds/bytes-as-text.json b/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/feeds/bytes-as-text.jsonnew file mode 100644index 00000000..4551bd0e--- /dev/null+++ b/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/feeds/bytes-as-text.json@@ -0,0 +1 @@+{"payload": "ewogInNjaGVtYSI6IDEsCiAic2VxdWVuY2UiOiA3LAogIm1vZGVscyI6IHsKICAibWluaSI6IHsKICAgImlvcyI6IFsKICAgIHsKICAgICAicmVsZWFzZSI6ICIxLjIuMCIsCiAgICAgInVybCI6ICJodHRwczovL21vZGVscy5mbHVpZHZvaWNlLmFwcC9wYXJha2VldC9mbHVpZC1taW5pLzEuMi4wL2ZsdWlkLXBhcmFrZWV0LW1pbmktY29yZW1sLnRhciIsCiAgICAgImJ5dGVzIjogIjI1NDEzNjMyMCIsCiAgICAgInNoYTI1NiI6ICJhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhIiwKICAgICAibWFuaWZlc3RTSEEyNTYiOiAiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYiIsCiAgICAgImZvcm1hdCI6IDEsCiAgICAgIm1pbkJ1aWxkIjogMTAKICAgIH0KICAgXSwKICAgIm1hY29zIjogW10KICB9LAogICJwaWNvIjogewogICAiaW9zIjogW10sCiAgICJtYWNvcyI6IFtdCiAgfQogfQp9", "signature": "SQUClvFvMGwjJTnwX3Lu9G442YRMxNqB7loemVxeTlWBIb7L1hotJVEv4ad1iC21hwiLYLFsxucDjWbtHhaYAQ=="}\ No newline at end of filediff --git a/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/feeds/bytes-fraction.json b/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/feeds/bytes-fraction.jsonnew file mode 100644index 00000000..d8751b28--- /dev/null+++ b/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/feeds/bytes-fraction.json@@ -0,0 +1 @@+{"payload": "ewogInNjaGVtYSI6IDEsCiAic2VxdWVuY2UiOiA3LAogIm1vZGVscyI6IHsKICAibWluaSI6IHsKICAgImlvcyI6IFsKICAgIHsKICAgICAicmVsZWFzZSI6ICIxLjIuMCIsCiAgICAgInVybCI6ICJodHRwczovL21vZGVscy5mbHVpZHZvaWNlLmFwcC9wYXJha2VldC9mbHVpZC1taW5pLzEuMi4wL2ZsdWlkLXBhcmFrZWV0LW1pbmktY29yZW1sLnRhciIsCiAgICAgImJ5dGVzIjogMjU0MTM2MzIwLjUsCiAgICAgInNoYTI1NiI6ICJhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhIiwKICAgICAibWFuaWZlc3RTSEEyNTYiOiAiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYiIsCiAgICAgImZvcm1hdCI6IDEsCiAgICAgIm1pbkJ1aWxkIjogMTAKICAgIH0KICAgXSwKICAgIm1hY29zIjogW10KICB9LAogICJwaWNvIjogewogICAiaW9zIjogW10sCiAgICJtYWNvcyI6IFtdCiAgfQogfQp9", "signature": "iJeSIoF+v87aNnvfidnJprSSCerPxyd15BgxhRWVQW7tnVaqsqj89ktfoGaQwbmzOHxlJD2wLbQDhnN/DjnAAw=="}\ No newline at end of filediff --git a/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/feeds/bytes-negative.json b/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/feeds/bytes-negative.jsonnew file mode 100644index 00000000..9695a20b--- /dev/null+++ b/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/feeds/bytes-negative.json@@ -0,0 +1 @@+{"payload": "ewogInNjaGVtYSI6IDEsCiAic2VxdWVuY2UiOiA3LAogIm1vZGVscyI6IHsKICAibWluaSI6IHsKICAgImlvcyI6IFsKICAgIHsKICAgICAicmVsZWFzZSI6ICIxLjIuMCIsCiAgICAgInVybCI6ICJodHRwczovL21vZGVscy5mbHVpZHZvaWNlLmFwcC9wYXJha2VldC9mbHVpZC1taW5pLzEuMi4wL2ZsdWlkLXBhcmFrZWV0LW1pbmktY29yZW1sLnRhciIsCiAgICAgImJ5dGVzIjogLTI1NDEzNjMyMCwKICAgICAic2hhMjU2IjogImFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWEiLAogICAgICJtYW5pZmVzdFNIQTI1NiI6ICJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiIiwKICAgICAiZm9ybWF0IjogMSwKICAgICAibWluQnVpbGQiOiAxMAogICAgfQogICBdLAogICAibWFjb3MiOiBbXQogIH0sCiAgInBpY28iOiB7CiAgICJpb3MiOiBbXSwKICAgIm1hY29zIjogW10KICB9CiB9Cn0=", "signature": "yBLydz7fMy8F8eJAMdmLuVNCjjw5RS9q3nQBlP06egiQVj44g3KwS0iVvhTV+92GQnu34YS1bqcBrV4ktf8wBw=="}\ No newline at end of filediff --git a/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/feeds/bytes-too-large.json b/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/feeds/bytes-too-large.jsonnew file mode 100644index 00000000..7af82ed6--- /dev/null+++ b/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/feeds/bytes-too-large.json@@ -0,0 +1 @@+{"payload": "ewogInNjaGVtYSI6IDEsCiAic2VxdWVuY2UiOiA3LAogIm1vZGVscyI6IHsKICAibWluaSI6IHsKICAgImlvcyI6IFsKICAgIHsKICAgICAicmVsZWFzZSI6ICIxLjIuMCIsCiAgICAgInVybCI6ICJodHRwczovL21vZGVscy5mbHVpZHZvaWNlLmFwcC9wYXJha2VldC9mbHVpZC1taW5pLzEuMi4wL2ZsdWlkLXBhcmFrZWV0LW1pbmktY29yZW1sLnRhciIsCiAgICAgImJ5dGVzIjogMjAwMDAwMDAwMCwKICAgICAic2hhMjU2IjogImFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWEiLAogICAgICJtYW5pZmVzdFNIQTI1NiI6ICJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiIiwKICAgICAiZm9ybWF0IjogMSwKICAgICAibWluQnVpbGQiOiAxMAogICAgfQogICBdLAogICAibWFjb3MiOiBbXQogIH0sCiAgInBpY28iOiB7CiAgICJpb3MiOiBbXSwKICAgIm1hY29zIjogW10KICB9CiB9Cn0=", "signature": "KZ+OUqlofC7C/5XKXQfjCeNbB71w+LKGU3XNSbtj8EJTtJ7pULiVLXts3oytwEaqpid0Y9o6+ESETBh8l+ONDg=="}\ No newline at end of filediff --git a/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/feeds/bytes-too-small.json b/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/feeds/bytes-too-small.jsonnew file mode 100644index 00000000..cf0fa7b3--- /dev/null+++ b/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/feeds/bytes-too-small.json@@ -0,0 +1 @@+{"payload": "ewogInNjaGVtYSI6IDEsCiAic2VxdWVuY2UiOiA3LAogIm1vZGVscyI6IHsKICAibWluaSI6IHsKICAgImlvcyI6IFsKICAgIHsKICAgICAicmVsZWFzZSI6ICIxLjIuMCIsCiAgICAgInVybCI6ICJodHRwczovL21vZGVscy5mbHVpZHZvaWNlLmFwcC9wYXJha2VldC9mbHVpZC1taW5pLzEuMi4wL2ZsdWlkLXBhcmFrZWV0LW1pbmktY29yZW1sLnRhciIsCiAgICAgImJ5dGVzIjogMTAwMCwKICAgICAic2hhMjU2IjogImFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWEiLAogICAgICJtYW5pZmVzdFNIQTI1NiI6ICJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiIiwKICAgICAiZm9ybWF0IjogMSwKICAgICAibWluQnVpbGQiOiAxMAogICAgfQogICBdLAogICAibWFjb3MiOiBbXQogIH0sCiAgInBpY28iOiB7CiAgICJpb3MiOiBbXSwKICAgIm1hY29zIjogW10KICB9CiB9Cn0=", "signature": "c41TknN1b7LXjf93NROGvol3iNUL5coK2DeoF94r1Cp9RY15F816h6x0R+LbYF3XLYOJJlyJVB+YZuvaUW0BAg=="}\ No newline at end of filediff --git a/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/feeds/expected.json b/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/feeds/expected.jsonnew file mode 100644index 00000000..6c4c28fa--- /dev/null+++ b/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/feeds/expected.json@@ -0,0 +1,202 @@+[+ {+ "file": "good.json",+ "lastSequence": 0,+ "verdict": "ok"+ },+ {+ "file": "good-same-sequence.json",+ "lastSequence": 7,+ "verdict": "ok"+ },+ {+ "file": "good-extra-fields.json",+ "lastSequence": 0,+ "verdict": "ok"+ },+ {+ "file": "good-no-models.json",+ "lastSequence": 0,+ "verdict": "ok"+ },+ {+ "file": "good-two-releases.json",+ "lastSequence": 0,+ "verdict": "ok"+ },+ {+ "file": "not-json.json",+ "lastSequence": 0,+ "verdict": "notAnEnvelope"+ },+ {+ "file": "missing-signature.json",+ "lastSequence": 0,+ "verdict": "notAnEnvelope"+ },+ {+ "file": "payload-not-base64.json",+ "lastSequence": 0,+ "verdict": "notAnEnvelope"+ },+ {+ "file": "oversized.json",+ "lastSequence": 0,+ "verdict": "tooLarge"+ },+ {+ "file": "bad-signature.json",+ "lastSequence": 0,+ "verdict": "badSignature"+ },+ {+ "file": "unknown-key.json",+ "lastSequence": 0,+ "verdict": "badSignature"+ },+ {+ "file": "payload-not-json.json",+ "lastSequence": 0,+ "verdict": "unreadablePayload"+ },+ {+ "file": "missing-field.json",+ "lastSequence": 0,+ "verdict": "unreadablePayload"+ },+ {+ "file": "bytes-as-text.json",+ "lastSequence": 0,+ "verdict": "unreadablePayload"+ },+ {+ "file": "bytes-fraction.json",+ "lastSequence": 0,+ "verdict": "unreadablePayload"+ },+ {+ "file": "models-wrong-shape.json",+ "lastSequence": 0,+ "verdict": "unreadablePayload"+ },+ {+ "file": "unknown-schema.json",+ "lastSequence": 0,+ "verdict": "unknownSchema"+ },+ {+ "file": "sequence-zero.json",+ "lastSequence": 0,+ "verdict": "staleSequence"+ },+ {+ "file": "lower-sequence.json",+ "lastSequence": 8,+ "verdict": "staleSequence"+ },+ {+ "file": "url-http.json",+ "lastSequence": 0,+ "verdict": "badEntry"+ },+ {+ "file": "url-wrong-host.json",+ "lastSequence": 0,+ "verdict": "badEntry"+ },+ {+ "file": "url-lookalike-host.json",+ "lastSequence": 0,+ "verdict": "badEntry"+ },+ {+ "file": "url-user-info.json",+ "lastSequence": 0,+ "verdict": "badEntry"+ },+ {+ "file": "url-port.json",+ "lastSequence": 0,+ "verdict": "badEntry"+ },+ {+ "file": "url-outside-prefix.json",+ "lastSequence": 0,+ "verdict": "badEntry"+ },+ {+ "file": "url-traversal.json",+ "lastSequence": 0,+ "verdict": "badEntry"+ },+ {+ "file": "url-encoded-traversal.json",+ "lastSequence": 0,+ "verdict": "badEntry"+ },+ {+ "file": "url-not-tar.json",+ "lastSequence": 0,+ "verdict": "badEntry"+ },+ {+ "file": "url-query.json",+ "lastSequence": 0,+ "verdict": "badEntry"+ },+ {+ "file": "hash-short.json",+ "lastSequence": 0,+ "verdict": "badEntry"+ },+ {+ "file": "hash-uppercase.json",+ "lastSequence": 0,+ "verdict": "badEntry"+ },+ {+ "file": "hash-not-hex.json",+ "lastSequence": 0,+ "verdict": "badEntry"+ },+ {+ "file": "bytes-too-small.json",+ "lastSequence": 0,+ "verdict": "badEntry"+ },+ {+ "file": "bytes-too-large.json",+ "lastSequence": 0,+ "verdict": "badEntry"+ },+ {+ "file": "bytes-negative.json",+ "lastSequence": 0,+ "verdict": "badEntry"+ },+ {+ "file": "format-zero.json",+ "lastSequence": 0,+ "verdict": "badEntry"+ },+ {+ "file": "min-build-zero.json",+ "lastSequence": 0,+ "verdict": "badEntry"+ },+ {+ "file": "release-empty.json",+ "lastSequence": 0,+ "verdict": "badEntry"+ },+ {+ "file": "release-odd-characters.json",+ "lastSequence": 0,+ "verdict": "badEntry"+ },+ {+ "file": "bad-entry-other-platform.json",+ "lastSequence": 0,+ "verdict": "badEntry"+ }+]diff --git a/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/feeds/format-zero.json b/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/feeds/format-zero.jsonnew file mode 100644index 00000000..8c6a890d--- /dev/null+++ b/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/feeds/format-zero.json@@ -0,0 +1 @@+{"payload": "ewogInNjaGVtYSI6IDEsCiAic2VxdWVuY2UiOiA3LAogIm1vZGVscyI6IHsKICAibWluaSI6IHsKICAgImlvcyI6IFsKICAgIHsKICAgICAicmVsZWFzZSI6ICIxLjIuMCIsCiAgICAgInVybCI6ICJodHRwczovL21vZGVscy5mbHVpZHZvaWNlLmFwcC9wYXJha2VldC9mbHVpZC1taW5pLzEuMi4wL2ZsdWlkLXBhcmFrZWV0LW1pbmktY29yZW1sLnRhciIsCiAgICAgImJ5dGVzIjogMjU0MTM2MzIwLAogICAgICJzaGEyNTYiOiAiYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYSIsCiAgICAgIm1hbmlmZXN0U0hBMjU2IjogImJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmIiLAogICAgICJmb3JtYXQiOiAwLAogICAgICJtaW5CdWlsZCI6IDEwCiAgICB9CiAgIF0sCiAgICJtYWNvcyI6IFtdCiAgfSwKICAicGljbyI6IHsKICAgImlvcyI6IFtdLAogICAibWFjb3MiOiBbXQogIH0KIH0KfQ==", "signature": "Lkd72dHgkQfsAd+m1yjMQMX85ZlrH21Ubn/Mjt/B7eGAAguE+28VtDrhI1lcP6i5SzldoPohQCdvUPM31f9KCQ=="}\ No newline at end of filediff --git a/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/feeds/good-extra-fields.json b/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/feeds/good-extra-fields.jsonnew file mode 100644index 00000000..b7861e64--- /dev/null+++ b/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/feeds/good-extra-fields.json@@ -0,0 +1 @@+{"payload": "ewogInNjaGVtYSI6IDEsCiAic2VxdWVuY2UiOiA3LAogIm1vZGVscyI6IHsKICAibWluaSI6IHsKICAgImlvcyI6IFsKICAgIHsKICAgICAicmVsZWFzZSI6ICIxLjIuMCIsCiAgICAgInVybCI6ICJodHRwczovL21vZGVscy5mbHVpZHZvaWNlLmFwcC9wYXJha2VldC9mbHVpZC1taW5pLzEuMi4wL2ZsdWlkLXBhcmFrZWV0LW1pbmktY29yZW1sLnRhciIsCiAgICAgImJ5dGVzIjogMjU0MTM2MzIwLAogICAgICJzaGEyNTYiOiAiYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYSIsCiAgICAgIm1hbmlmZXN0U0hBMjU2IjogImJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmIiLAogICAgICJmb3JtYXQiOiAxLAogICAgICJtaW5CdWlsZCI6IDEwLAogICAgICJ3ZXIiOiA0LjM3LAogICAgICJub3RlIjogIngiCiAgICB9CiAgIF0sCiAgICJtYWNvcyI6IFtdCiAgfSwKICAicGljbyI6IHsKICAgImlvcyI6IFtdLAogICAibWFjb3MiOiBbXQogIH0KIH0sCiAidXBkYXRlZCI6ICIyMDI2LTEwLTA1Igp9", "signature": "cyblVK+R+1aJf8WsAgb6xurZhbjdmTgQh/oDnlrfxuOfqrjcf8npPWCKjNJY4xgQZqaN8q+VDF/zs/J9jsdiDA=="}\ No newline at end of filediff --git a/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/feeds/good-no-models.json b/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/feeds/good-no-models.jsonnew file mode 100644index 00000000..e0461d32--- /dev/null+++ b/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/feeds/good-no-models.json@@ -0,0 +1 @@+{"payload": "ewogInNjaGVtYSI6IDEsCiAic2VxdWVuY2UiOiA3LAogIm1vZGVscyI6IHt9Cn0=", "signature": "B8BomdL4X7ta70aTnXY4x3IJf+PiJG0LdoEr0+2r2dPwWjzdsPQTt8222cGUuqu2DIaRi9vI/fnmuw/Yb1J2Dg=="}\ No newline at end of filediff --git a/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/feeds/good-same-sequence.json b/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/feeds/good-same-sequence.jsonnew file mode 100644index 00000000..91f42ccc--- /dev/null+++ b/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/feeds/good-same-sequence.json@@ -0,0 +1 @@+{"payload": "ewogInNjaGVtYSI6IDEsCiAic2VxdWVuY2UiOiA3LAogIm1vZGVscyI6IHsKICAibWluaSI6IHsKICAgImlvcyI6IFsKICAgIHsKICAgICAicmVsZWFzZSI6ICIxLjIuMCIsCiAgICAgInVybCI6ICJodHRwczovL21vZGVscy5mbHVpZHZvaWNlLmFwcC9wYXJha2VldC9mbHVpZC1taW5pLzEuMi4wL2ZsdWlkLXBhcmFrZWV0LW1pbmktY29yZW1sLnRhciIsCiAgICAgImJ5dGVzIjogMjU0MTM2MzIwLAogICAgICJzaGEyNTYiOiAiYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYSIsCiAgICAgIm1hbmlmZXN0U0hBMjU2IjogImJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmIiLAogICAgICJmb3JtYXQiOiAxLAogICAgICJtaW5CdWlsZCI6IDEwCiAgICB9CiAgIF0sCiAgICJtYWNvcyI6IFtdCiAgfSwKICAicGljbyI6IHsKICAgImlvcyI6IFtdLAogICAibWFjb3MiOiBbXQogIH0KIH0KfQ==", "signature": "zxFEaNeNNWXIOLT0Rp1a/T0z7D21WwHaJGpcXw1boPhSI5gm5HtS4Ax195LB0fj+0i+B6T0sb9tUNOLFM+AuCA=="}\ No newline at end of filediff --git a/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/feeds/good-two-releases.json b/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/feeds/good-two-releases.jsonnew file mode 100644index 00000000..57db7318--- /dev/null+++ b/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/feeds/good-two-releases.json@@ -0,0 +1 @@+{"payload": "ewogInNjaGVtYSI6IDEsCiAic2VxdWVuY2UiOiA3LAogIm1vZGVscyI6IHsKICAibWluaSI6IHsKICAgImlvcyI6IFsKICAgIHsKICAgICAicmVsZWFzZSI6ICIyLjAuMCIsCiAgICAgInVybCI6ICJodHRwczovL21vZGVscy5mbHVpZHZvaWNlLmFwcC9wYXJha2VldC9mbHVpZC1taW5pLzEuMi4wL2ZsdWlkLXBhcmFrZWV0LW1pbmktY29yZW1sLnRhciIsCiAgICAgImJ5dGVzIjogMjU0MTM2MzIwLAogICAgICJzaGEyNTYiOiAiYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYSIsCiAgICAgIm1hbmlmZXN0U0hBMjU2IjogImJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmIiLAogICAgICJmb3JtYXQiOiAyLAogICAgICJtaW5CdWlsZCI6IDIwCiAgICB9LAogICAgewogICAgICJyZWxlYXNlIjogIjEuMi4wIiwKICAgICAidXJsIjogImh0dHBzOi8vbW9kZWxzLmZsdWlkdm9pY2UuYXBwL3BhcmFrZWV0L2ZsdWlkLW1pbmkvMS4yLjAvZmx1aWQtcGFyYWtlZXQtbWluaS1jb3JlbWwudGFyIiwKICAgICAiYnl0ZXMiOiAyNTQxMzYzMjAsCiAgICAgInNoYTI1NiI6ICJhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhIiwKICAgICAibWFuaWZlc3RTSEEyNTYiOiAiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYiIsCiAgICAgImZvcm1hdCI6IDEsCiAgICAgIm1pbkJ1aWxkIjogMTAKICAgIH0KICAgXSwKICAgIm1hY29zIjogW10KICB9LAogICJwaWNvIjogewogICAiaW9zIjogW10sCiAgICJtYWNvcyI6IFtdCiAgfQogfQp9", "signature": "Cnbh+LAG9qZiHqrxV71Ba4tws2LEgIEb8/LFoVpr/tZDZpkD+R3JseWZN+eP3CGrElsMGus4KJq2DZLHAjzdCw=="}\ No newline at end of filediff --git a/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/feeds/good.json b/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/feeds/good.jsonnew file mode 100644index 00000000..91f42ccc--- /dev/null+++ b/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/feeds/good.json@@ -0,0 +1 @@+{"payload": "ewogInNjaGVtYSI6IDEsCiAic2VxdWVuY2UiOiA3LAogIm1vZGVscyI6IHsKICAibWluaSI6IHsKICAgImlvcyI6IFsKICAgIHsKICAgICAicmVsZWFzZSI6ICIxLjIuMCIsCiAgICAgInVybCI6ICJodHRwczovL21vZGVscy5mbHVpZHZvaWNlLmFwcC9wYXJha2VldC9mbHVpZC1taW5pLzEuMi4wL2ZsdWlkLXBhcmFrZWV0LW1pbmktY29yZW1sLnRhciIsCiAgICAgImJ5dGVzIjogMjU0MTM2MzIwLAogICAgICJzaGEyNTYiOiAiYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYSIsCiAgICAgIm1hbmlmZXN0U0hBMjU2IjogImJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmIiLAogICAgICJmb3JtYXQiOiAxLAogICAgICJtaW5CdWlsZCI6IDEwCiAgICB9CiAgIF0sCiAgICJtYWNvcyI6IFtdCiAgfSwKICAicGljbyI6IHsKICAgImlvcyI6IFtdLAogICAibWFjb3MiOiBbXQogIH0KIH0KfQ==", "signature": "zxFEaNeNNWXIOLT0Rp1a/T0z7D21WwHaJGpcXw1boPhSI5gm5HtS4Ax195LB0fj+0i+B6T0sb9tUNOLFM+AuCA=="}\ No newline at end of filediff --git a/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/feeds/hash-not-hex.json b/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/feeds/hash-not-hex.jsonnew file mode 100644index 00000000..4d7dfe21--- /dev/null+++ b/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/feeds/hash-not-hex.json@@ -0,0 +1 @@+{"payload": "ewogInNjaGVtYSI6IDEsCiAic2VxdWVuY2UiOiA3LAogIm1vZGVscyI6IHsKICAibWluaSI6IHsKICAgImlvcyI6IFsKICAgIHsKICAgICAicmVsZWFzZSI6ICIxLjIuMCIsCiAgICAgInVybCI6ICJodHRwczovL21vZGVscy5mbHVpZHZvaWNlLmFwcC9wYXJha2VldC9mbHVpZC1taW5pLzEuMi4wL2ZsdWlkLXBhcmFrZWV0LW1pbmktY29yZW1sLnRhciIsCiAgICAgImJ5dGVzIjogMjU0MTM2MzIwLAogICAgICJzaGEyNTYiOiAiYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYSIsCiAgICAgIm1hbmlmZXN0U0hBMjU2IjogImdnZ2dnZ2dnZ2dnZ2dnZ2dnZ2dnZ2dnZ2dnZ2dnZ2dnZ2dnZ2dnZ2dnZ2dnZ2dnZ2dnZ2dnZ2dnZ2dnZ2dnZ2ciLAogICAgICJmb3JtYXQiOiAxLAogICAgICJtaW5CdWlsZCI6IDEwCiAgICB9CiAgIF0sCiAgICJtYWNvcyI6IFtdCiAgfSwKICAicGljbyI6IHsKICAgImlvcyI6IFtdLAogICAibWFjb3MiOiBbXQogIH0KIH0KfQ==", "signature": "WX+FX33It6l6xIV4EVh38238I9lJ8V1Iztz/dS7dl4ynqceCUPWthnmQIaasnZgPVOqCqGCu94vIkjiWbb8XCQ=="}\ No newline at end of filediff --git a/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/feeds/hash-short.json b/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/feeds/hash-short.jsonnew file mode 100644index 00000000..25f5b76f--- /dev/null+++ b/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/feeds/hash-short.json@@ -0,0 +1 @@+{"payload": "ewogInNjaGVtYSI6IDEsCiAic2VxdWVuY2UiOiA3LAogIm1vZGVscyI6IHsKICAibWluaSI6IHsKICAgImlvcyI6IFsKICAgIHsKICAgICAicmVsZWFzZSI6ICIxLjIuMCIsCiAgICAgInVybCI6ICJodHRwczovL21vZGVscy5mbHVpZHZvaWNlLmFwcC9wYXJha2VldC9mbHVpZC1taW5pLzEuMi4wL2ZsdWlkLXBhcmFrZWV0LW1pbmktY29yZW1sLnRhciIsCiAgICAgImJ5dGVzIjogMjU0MTM2MzIwLAogICAgICJzaGEyNTYiOiAiYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhIiwKICAgICAibWFuaWZlc3RTSEEyNTYiOiAiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYiIsCiAgICAgImZvcm1hdCI6IDEsCiAgICAgIm1pbkJ1aWxkIjogMTAKICAgIH0KICAgXSwKICAgIm1hY29zIjogW10KICB9LAogICJwaWNvIjogewogICAiaW9zIjogW10sCiAgICJtYWNvcyI6IFtdCiAgfQogfQp9", "signature": "+yRxthv8tXNamT/HInVw9V/blTRnvqzT85Zru5SRqYbPVU/eUMBLq5rVhPyy+XhaoKPWVeMBFfk7DjpMnUElAg=="}\ No newline at end of filediff --git a/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/feeds/hash-uppercase.json b/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/feeds/hash-uppercase.jsonnew file mode 100644index 00000000..f27f60e4--- /dev/null+++ b/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/feeds/hash-uppercase.json@@ -0,0 +1 @@+{"payload": "ewogInNjaGVtYSI6IDEsCiAic2VxdWVuY2UiOiA3LAogIm1vZGVscyI6IHsKICAibWluaSI6IHsKICAgImlvcyI6IFsKICAgIHsKICAgICAicmVsZWFzZSI6ICIxLjIuMCIsCiAgICAgInVybCI6ICJodHRwczovL21vZGVscy5mbHVpZHZvaWNlLmFwcC9wYXJha2VldC9mbHVpZC1taW5pLzEuMi4wL2ZsdWlkLXBhcmFrZWV0LW1pbmktY29yZW1sLnRhciIsCiAgICAgImJ5dGVzIjogMjU0MTM2MzIwLAogICAgICJzaGEyNTYiOiAiQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQSIsCiAgICAgIm1hbmlmZXN0U0hBMjU2IjogImJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmIiLAogICAgICJmb3JtYXQiOiAxLAogICAgICJtaW5CdWlsZCI6IDEwCiAgICB9CiAgIF0sCiAgICJtYWNvcyI6IFtdCiAgfSwKICAicGljbyI6IHsKICAgImlvcyI6IFtdLAogICAibWFjb3MiOiBbXQogIH0KIH0KfQ==", "signature": "lV9DsjrcH24Rw5BijrBI2kjD5umXQs6UtodXncgD8sUwpygAKWBdsU8rDPFhxyzhGp/gYObbYPfABEaoAUs7CQ=="}\ No newline at end of filediff --git a/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/feeds/lower-sequence.json b/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/feeds/lower-sequence.jsonnew file mode 100644index 00000000..91f42ccc--- /dev/null+++ b/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/feeds/lower-sequence.json@@ -0,0 +1 @@+{"payload": "ewogInNjaGVtYSI6IDEsCiAic2VxdWVuY2UiOiA3LAogIm1vZGVscyI6IHsKICAibWluaSI6IHsKICAgImlvcyI6IFsKICAgIHsKICAgICAicmVsZWFzZSI6ICIxLjIuMCIsCiAgICAgInVybCI6ICJodHRwczovL21vZGVscy5mbHVpZHZvaWNlLmFwcC9wYXJha2VldC9mbHVpZC1taW5pLzEuMi4wL2ZsdWlkLXBhcmFrZWV0LW1pbmktY29yZW1sLnRhciIsCiAgICAgImJ5dGVzIjogMjU0MTM2MzIwLAogICAgICJzaGEyNTYiOiAiYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYSIsCiAgICAgIm1hbmlmZXN0U0hBMjU2IjogImJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmIiLAogICAgICJmb3JtYXQiOiAxLAogICAgICJtaW5CdWlsZCI6IDEwCiAgICB9CiAgIF0sCiAgICJtYWNvcyI6IFtdCiAgfSwKICAicGljbyI6IHsKICAgImlvcyI6IFtdLAogICAibWFjb3MiOiBbXQogIH0KIH0KfQ==", "signature": "zxFEaNeNNWXIOLT0Rp1a/T0z7D21WwHaJGpcXw1boPhSI5gm5HtS4Ax195LB0fj+0i+B6T0sb9tUNOLFM+AuCA=="}\ No newline at end of filediff --git a/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/feeds/min-build-zero.json b/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/feeds/min-build-zero.jsonnew file mode 100644index 00000000..8de42e1e--- /dev/null+++ b/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/feeds/min-build-zero.json@@ -0,0 +1 @@+{"payload": "ewogInNjaGVtYSI6IDEsCiAic2VxdWVuY2UiOiA3LAogIm1vZGVscyI6IHsKICAibWluaSI6IHsKICAgImlvcyI6IFsKICAgIHsKICAgICAicmVsZWFzZSI6ICIxLjIuMCIsCiAgICAgInVybCI6ICJodHRwczovL21vZGVscy5mbHVpZHZvaWNlLmFwcC9wYXJha2VldC9mbHVpZC1taW5pLzEuMi4wL2ZsdWlkLXBhcmFrZWV0LW1pbmktY29yZW1sLnRhciIsCiAgICAgImJ5dGVzIjogMjU0MTM2MzIwLAogICAgICJzaGEyNTYiOiAiYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYSIsCiAgICAgIm1hbmlmZXN0U0hBMjU2IjogImJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmIiLAogICAgICJmb3JtYXQiOiAxLAogICAgICJtaW5CdWlsZCI6IDAKICAgIH0KICAgXSwKICAgIm1hY29zIjogW10KICB9LAogICJwaWNvIjogewogICAiaW9zIjogW10sCiAgICJtYWNvcyI6IFtdCiAgfQogfQp9", "signature": "d00ylzL7gYRli9ltJ9QvzC4DG5rcv94WpbeexOpF4nvqy19TpLh4QheWBsyGi/uFI2WtH5X+/IWWmUU1BnQUBw=="}\ No newline at end of filediff --git a/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/feeds/missing-field.json b/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/feeds/missing-field.jsonnew file mode 100644index 00000000..266d3f21--- /dev/null+++ b/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/feeds/missing-field.json@@ -0,0 +1 @@+{"payload": "ewogInNjaGVtYSI6IDEsCiAic2VxdWVuY2UiOiA3LAogIm1vZGVscyI6IHsKICAibWluaSI6IHsKICAgImlvcyI6IFsKICAgIHsKICAgICAicmVsZWFzZSI6ICIxLjIuMCIsCiAgICAgInVybCI6ICJodHRwczovL21vZGVscy5mbHVpZHZvaWNlLmFwcC9wYXJha2VldC9mbHVpZC1taW5pLzEuMi4wL2ZsdWlkLXBhcmFrZWV0LW1pbmktY29yZW1sLnRhciIsCiAgICAgImJ5dGVzIjogMjU0MTM2MzIwLAogICAgICJtYW5pZmVzdFNIQTI1NiI6ICJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiIiwKICAgICAiZm9ybWF0IjogMSwKICAgICAibWluQnVpbGQiOiAxMAogICAgfQogICBdLAogICAibWFjb3MiOiBbXQogIH0sCiAgInBpY28iOiB7CiAgICJpb3MiOiBbXSwKICAgIm1hY29zIjogW10KICB9CiB9Cn0=", "signature": "LTXEzc8mj2C1IQjxfD0WrXUMwD2OZHnC9SJBb1lscU6/6OabmbFM0JnkniTpNp2HrwWK0SkIYTSU7X5OTERkBA=="}\ No newline at end of filediff --git a/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/feeds/missing-signature.json b/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/feeds/missing-signature.jsonnew file mode 100644index 00000000..0d5082d6--- /dev/null+++ b/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/feeds/missing-signature.json@@ -0,0 +1 @@+{"payload": "e30="}\ No newline at end of filediff --git a/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/feeds/models-wrong-shape.json b/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/feeds/models-wrong-shape.jsonnew file mode 100644index 00000000..0909aa4e--- /dev/null+++ b/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/feeds/models-wrong-shape.json@@ -0,0 +1 @@+{"payload": "ewogInNjaGVtYSI6IDEsCiAic2VxdWVuY2UiOiA3LAogIm1vZGVscyI6IHsKICAibWluaSI6IFsKICAgewogICAgInJlbGVhc2UiOiAiMS4yLjAiLAogICAgInVybCI6ICJodHRwczovL21vZGVscy5mbHVpZHZvaWNlLmFwcC9wYXJha2VldC9mbHVpZC1taW5pLzEuMi4wL2ZsdWlkLXBhcmFrZWV0LW1pbmktY29yZW1sLnRhciIsCiAgICAiYnl0ZXMiOiAyNTQxMzYzMjAsCiAgICAic2hhMjU2IjogImFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWEiLAogICAgIm1hbmlmZXN0U0hBMjU2IjogImJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmIiLAogICAgImZvcm1hdCI6IDEsCiAgICAibWluQnVpbGQiOiAxMAogICB9CiAgXQogfQp9", "signature": "blLS9wgH1UVZCBir2WtFgX9WVsLUaHAWwaDPIU3Ob5YA5zCItE8qzABzfn2HW8yTP16VEk+/Us3mZxFaxBy9BA=="}\ No newline at end of filediff --git a/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/feeds/not-json.json b/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/feeds/not-json.jsonnew file mode 100644index 00000000..36efa5ac--- /dev/null+++ b/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/feeds/not-json.json@@ -0,0 +1 @@+<html>503</html>\ No newline at end of filediff --git a/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/feeds/oversized.json b/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/feeds/oversized.jsonnew file mode 100644index 00000000..32e3bdf1--- /dev/null+++ b/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/feeds/oversized.json@@ -0,0 +1 @@+{"payload": "{
 "schema": 1,
 "sequence": 7,
 "models": {
  "mini": {
   "ios": [
    {
     "release": "1.2.0",
     "url": "https://models.fluidvoice.app/parakeet/fluid-mini/1.2.0/fluid-parakeet-mini-coreml.tar",
     "bytes": 254136320,
     "sha256": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
     "manifestSHA256": "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb",
     "format": 1,
     "minBuild": 10
    }
   ],
   "macos": []
  },
  "pico": {
   "ios": [],
   "macos": []
  }
 },
 "padding": "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
}", "signature": "o39drwgZqS9P7KPUvxG0kLjGVh49aSwYHEV2hCO9rkX5sW7itZS1gyyyz1Q5cnwfHt6cc/Pvus8IUjYOLVCqCQ=="}\ No newline at end of filediff --git a/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/feeds/payload-not-base64.json b/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/feeds/payload-not-base64.jsonnew file mode 100644index 00000000..45f4f9e2--- /dev/null+++ b/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/feeds/payload-not-base64.json@@ -0,0 +1 @@+{"payload": "***", "signature": "AAAA"}\ No newline at end of filediff --git a/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/feeds/payload-not-json.json b/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/feeds/payload-not-json.jsonnew file mode 100644index 00000000..fbb9b0de--- /dev/null+++ b/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/feeds/payload-not-json.json@@ -0,0 +1 @@+{"payload": "bm90IGpzb24=", "signature": "Fg5bSxoGzO5WPQB0F3BODWfCU/IoC5aXrdzH1jTJy265OUgTg6YziMfOfPoyX51SGzJg4WvIukm6SfVI0fvxCw=="}\ No newline at end of filediff --git a/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/feeds/picks.json b/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/feeds/picks.jsonnew file mode 100644index 00000000..fc11703c--- /dev/null+++ b/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/feeds/picks.json@@ -0,0 +1,58 @@+[+ {+ "file": "good-two-releases.json",+ "model": "mini",+ "platform": "ios",+ "build": 25,+ "format": 2,+ "release": "2.0.0"+ },+ {+ "file": "good-two-releases.json",+ "model": "mini",+ "platform": "ios",+ "build": 25,+ "format": 1,+ "release": "1.2.0"+ },+ {+ "file": "good-two-releases.json",+ "model": "mini",+ "platform": "ios",+ "build": 12,+ "format": 2,+ "release": "1.2.0"+ },+ {+ "file": "good-two-releases.json",+ "model": "mini",+ "platform": "ios",+ "build": 9,+ "format": 2,+ "release": null+ },+ {+ "file": "good-two-releases.json",+ "model": "mini",+ "platform": "macos",+ "build": 25,+ "format": 2,+ "release": null+ },+ {+ "file": "good-two-releases.json",+ "model": "pico",+ "platform": "ios",+ "build": 25,+ "format": 2,+ "release": null+ },+ {+ "file": "good-two-releases.json",+ "model": "v3",+ "platform": "ios",+ "build": 25,+ "format": 2,+ "release": null+ }+]diff --git a/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/feeds/release-empty.json b/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/feeds/release-empty.jsonnew file mode 100644index 00000000..c56b962b--- /dev/null+++ b/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/feeds/release-empty.json@@ -0,0 +1 @@+{"payload": "ewogInNjaGVtYSI6IDEsCiAic2VxdWVuY2UiOiA3LAogIm1vZGVscyI6IHsKICAibWluaSI6IHsKICAgImlvcyI6IFsKICAgIHsKICAgICAicmVsZWFzZSI6ICIiLAogICAgICJ1cmwiOiAiaHR0cHM6Ly9tb2RlbHMuZmx1aWR2b2ljZS5hcHAvcGFyYWtlZXQvZmx1aWQtbWluaS8xLjIuMC9mbHVpZC1wYXJha2VldC1taW5pLWNvcmVtbC50YXIiLAogICAgICJieXRlcyI6IDI1NDEzNjMyMCwKICAgICAic2hhMjU2IjogImFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWEiLAogICAgICJtYW5pZmVzdFNIQTI1NiI6ICJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiIiwKICAgICAiZm9ybWF0IjogMSwKICAgICAibWluQnVpbGQiOiAxMAogICAgfQogICBdLAogICAibWFjb3MiOiBbXQogIH0sCiAgInBpY28iOiB7CiAgICJpb3MiOiBbXSwKICAgIm1hY29zIjogW10KICB9CiB9Cn0=", "signature": "vLb8bUR0oejnsxHTuD0f9Q86RvJrEe9YCxPlaEztPj5iFXDqDCGWtDOgO/e9vJnM8cESbahdaMlQr4sy5FZDBg=="}\ No newline at end of filediff --git a/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/feeds/release-odd-characters.json b/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/feeds/release-odd-characters.jsonnew file mode 100644index 00000000..225a0c15--- /dev/null+++ b/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/feeds/release-odd-characters.json@@ -0,0 +1 @@+{"payload": "ewogInNjaGVtYSI6IDEsCiAic2VxdWVuY2UiOiA3LAogIm1vZGVscyI6IHsKICAibWluaSI6IHsKICAgImlvcyI6IFsKICAgIHsKICAgICAicmVsZWFzZSI6ICIxLjIuMC8uLi94IiwKICAgICAidXJsIjogImh0dHBzOi8vbW9kZWxzLmZsdWlkdm9pY2UuYXBwL3BhcmFrZWV0L2ZsdWlkLW1pbmkvMS4yLjAvZmx1aWQtcGFyYWtlZXQtbWluaS1jb3JlbWwudGFyIiwKICAgICAiYnl0ZXMiOiAyNTQxMzYzMjAsCiAgICAgInNoYTI1NiI6ICJhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhIiwKICAgICAibWFuaWZlc3RTSEEyNTYiOiAiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYiIsCiAgICAgImZvcm1hdCI6IDEsCiAgICAgIm1pbkJ1aWxkIjogMTAKICAgIH0KICAgXSwKICAgIm1hY29zIjogW10KICB9LAogICJwaWNvIjogewogICAiaW9zIjogW10sCiAgICJtYWNvcyI6IFtdCiAgfQogfQp9", "signature": "uZRQVvSUSi3v+zizNGTTtrDYhm86xwCDtWob3wgN+gPtdA0gzxmxsgpspwEaZ9K70B8bh0GIDECU5wQH3BUuCw=="}\ No newline at end of filediff --git a/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/feeds/sequence-zero.json b/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/feeds/sequence-zero.jsonnew file mode 100644index 00000000..0ff73fe3--- /dev/null+++ b/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/feeds/sequence-zero.json@@ -0,0 +1 @@+{"payload": "ewogInNjaGVtYSI6IDEsCiAic2VxdWVuY2UiOiAwLAogIm1vZGVscyI6IHsKICAibWluaSI6IHsKICAgImlvcyI6IFsKICAgIHsKICAgICAicmVsZWFzZSI6ICIxLjIuMCIsCiAgICAgInVybCI6ICJodHRwczovL21vZGVscy5mbHVpZHZvaWNlLmFwcC9wYXJha2VldC9mbHVpZC1taW5pLzEuMi4wL2ZsdWlkLXBhcmFrZWV0LW1pbmktY29yZW1sLnRhciIsCiAgICAgImJ5dGVzIjogMjU0MTM2MzIwLAogICAgICJzaGEyNTYiOiAiYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYSIsCiAgICAgIm1hbmlmZXN0U0hBMjU2IjogImJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmIiLAogICAgICJmb3JtYXQiOiAxLAogICAgICJtaW5CdWlsZCI6IDEwCiAgICB9CiAgIF0sCiAgICJtYWNvcyI6IFtdCiAgfSwKICAicGljbyI6IHsKICAgImlvcyI6IFtdLAogICAibWFjb3MiOiBbXQogIH0KIH0KfQ==", "signature": "DHXJJIKkZtqfX/x1zQeaAKM2qwqaH537uCAYDxn7uqK65EOGoQui+ozTQcc1G3T83qh4cX+ZBJ5uhE09FlORCA=="}\ No newline at end of filediff --git a/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/feeds/unknown-key.json b/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/feeds/unknown-key.jsonnew file mode 100644index 00000000..383d547e--- /dev/null+++ b/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/feeds/unknown-key.json@@ -0,0 +1 @@+{"payload": "ewogInNjaGVtYSI6IDEsCiAic2VxdWVuY2UiOiA3LAogIm1vZGVscyI6IHsKICAibWluaSI6IHsKICAgImlvcyI6IFsKICAgIHsKICAgICAicmVsZWFzZSI6ICIxLjIuMCIsCiAgICAgInVybCI6ICJodHRwczovL21vZGVscy5mbHVpZHZvaWNlLmFwcC9wYXJha2VldC9mbHVpZC1taW5pLzEuMi4wL2ZsdWlkLXBhcmFrZWV0LW1pbmktY29yZW1sLnRhciIsCiAgICAgImJ5dGVzIjogMjU0MTM2MzIwLAogICAgICJzaGEyNTYiOiAiYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYSIsCiAgICAgIm1hbmlmZXN0U0hBMjU2IjogImJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmIiLAogICAgICJmb3JtYXQiOiAxLAogICAgICJtaW5CdWlsZCI6IDEwCiAgICB9CiAgIF0sCiAgICJtYWNvcyI6IFtdCiAgfSwKICAicGljbyI6IHsKICAgImlvcyI6IFtdLAogICAibWFjb3MiOiBbXQogIH0KIH0KfQ==", "signature": "VDk0YvsKPgqFf5FAVXXcMieYgORw1Pp4suTtjhUpQTBUIQP44HAKRJZuJchwxqEwO8IXT7vQ73JgfKtZ2UaBCQ=="}\ No newline at end of filediff --git a/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/feeds/unknown-schema.json b/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/feeds/unknown-schema.jsonnew file mode 100644index 00000000..034de84c--- /dev/null+++ b/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/feeds/unknown-schema.json@@ -0,0 +1 @@+{"payload": "ewogInNjaGVtYSI6IDIsCiAic2VxdWVuY2UiOiA3LAogIm1vZGVscyI6IHsKICAibWluaSI6IHsKICAgImlvcyI6IFsKICAgIHsKICAgICAicmVsZWFzZSI6ICIxLjIuMCIsCiAgICAgInVybCI6ICJodHRwczovL21vZGVscy5mbHVpZHZvaWNlLmFwcC9wYXJha2VldC9mbHVpZC1taW5pLzEuMi4wL2ZsdWlkLXBhcmFrZWV0LW1pbmktY29yZW1sLnRhciIsCiAgICAgImJ5dGVzIjogMjU0MTM2MzIwLAogICAgICJzaGEyNTYiOiAiYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYSIsCiAgICAgIm1hbmlmZXN0U0hBMjU2IjogImJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmIiLAogICAgICJmb3JtYXQiOiAxLAogICAgICJtaW5CdWlsZCI6IDEwCiAgICB9CiAgIF0sCiAgICJtYWNvcyI6IFtdCiAgfSwKICAicGljbyI6IHsKICAgImlvcyI6IFtdLAogICAibWFjb3MiOiBbXQogIH0KIH0KfQ==", "signature": "jFCV663+mFCakv+jTrNwPx3IFkVsyaN0e9RxMIcxD8/9gryxcxw8a+HnXby3Yub+CMmqYAoiTpauHg+h6IpDAg=="}\ No newline at end of filediff --git a/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/feeds/url-encoded-traversal.json b/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/feeds/url-encoded-traversal.jsonnew file mode 100644index 00000000..4dff04a5--- /dev/null+++ b/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/feeds/url-encoded-traversal.json@@ -0,0 +1 @@+{"payload": "ewogInNjaGVtYSI6IDEsCiAic2VxdWVuY2UiOiA3LAogIm1vZGVscyI6IHsKICAibWluaSI6IHsKICAgImlvcyI6IFsKICAgIHsKICAgICAicmVsZWFzZSI6ICIxLjIuMCIsCiAgICAgInVybCI6ICJodHRwczovL21vZGVscy5mbHVpZHZvaWNlLmFwcC9wYXJha2VldC8lMmUlMmUvZmVlZC9mbHVpZC1wYXJha2VldC1taW5pLWNvcmVtbC50YXIiLAogICAgICJieXRlcyI6IDI1NDEzNjMyMCwKICAgICAic2hhMjU2IjogImFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWEiLAogICAgICJtYW5pZmVzdFNIQTI1NiI6ICJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiIiwKICAgICAiZm9ybWF0IjogMSwKICAgICAibWluQnVpbGQiOiAxMAogICAgfQogICBdLAogICAibWFjb3MiOiBbXQogIH0sCiAgInBpY28iOiB7CiAgICJpb3MiOiBbXSwKICAgIm1hY29zIjogW10KICB9CiB9Cn0=", "signature": "1YA76donzCtjshTBex8rOsgscvQyQvyGcFyQEwQnTnOqpV7CAKuuaUCgJmwoTRuPaFCYy5tqKgd1lYVe22/vDA=="}\ No newline at end of filediff --git a/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/feeds/url-http.json b/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/feeds/url-http.jsonnew file mode 100644index 00000000..3bc9ff91--- /dev/null+++ b/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/feeds/url-http.json@@ -0,0 +1 @@+{"payload": "ewogInNjaGVtYSI6IDEsCiAic2VxdWVuY2UiOiA3LAogIm1vZGVscyI6IHsKICAibWluaSI6IHsKICAgImlvcyI6IFsKICAgIHsKICAgICAicmVsZWFzZSI6ICIxLjIuMCIsCiAgICAgInVybCI6ICJodHRwOi8vbW9kZWxzLmZsdWlkdm9pY2UuYXBwL3BhcmFrZWV0L2ZsdWlkLW1pbmkvMS4yLjAvZmx1aWQtcGFyYWtlZXQtbWluaS1jb3JlbWwudGFyIiwKICAgICAiYnl0ZXMiOiAyNTQxMzYzMjAsCiAgICAgInNoYTI1NiI6ICJhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhIiwKICAgICAibWFuaWZlc3RTSEEyNTYiOiAiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYiIsCiAgICAgImZvcm1hdCI6IDEsCiAgICAgIm1pbkJ1aWxkIjogMTAKICAgIH0KICAgXSwKICAgIm1hY29zIjogW10KICB9LAogICJwaWNvIjogewogICAiaW9zIjogW10sCiAgICJtYWNvcyI6IFtdCiAgfQogfQp9", "signature": "2JJ0KZCyJWC+YmC38wDmMgvUXTDb00Yg87i18AcroDSYl3sN6NfSWc3A4R/V8tqhCVevoXVXScl0PUbv5kFWAw=="}\ No newline at end of filediff --git a/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/feeds/url-lookalike-host.json b/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/feeds/url-lookalike-host.jsonnew file mode 100644index 00000000..e1ae9b09--- /dev/null+++ b/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/feeds/url-lookalike-host.json@@ -0,0 +1 @@+{"payload": "ewogInNjaGVtYSI6IDEsCiAic2VxdWVuY2UiOiA3LAogIm1vZGVscyI6IHsKICAibWluaSI6IHsKICAgImlvcyI6IFsKICAgIHsKICAgICAicmVsZWFzZSI6ICIxLjIuMCIsCiAgICAgInVybCI6ICJodHRwczovL21vZGVscy5mbHVpZHZvaWNlLmFwcC5leGFtcGxlLmNvbS9wYXJha2VldC9mbHVpZC1wYXJha2VldC1taW5pLWNvcmVtbC50YXIiLAogICAgICJieXRlcyI6IDI1NDEzNjMyMCwKICAgICAic2hhMjU2IjogImFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWEiLAogICAgICJtYW5pZmVzdFNIQTI1NiI6ICJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiIiwKICAgICAiZm9ybWF0IjogMSwKICAgICAibWluQnVpbGQiOiAxMAogICAgfQogICBdLAogICAibWFjb3MiOiBbXQogIH0sCiAgInBpY28iOiB7CiAgICJpb3MiOiBbXSwKICAgIm1hY29zIjogW10KICB9CiB9Cn0=", "signature": "21odh0opzpKD8nl1EFperxo0PmeJjqv5X76mcqsf8RiYEjKLIGwWurGGkgn4AOEOQ5/xDtEu1vgduLDanHeEDA=="}\ No newline at end of filediff --git a/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/feeds/url-not-tar.json b/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/feeds/url-not-tar.jsonnew file mode 100644index 00000000..872d7478--- /dev/null+++ b/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/feeds/url-not-tar.json@@ -0,0 +1 @@+{"payload": "ewogInNjaGVtYSI6IDEsCiAic2VxdWVuY2UiOiA3LAogIm1vZGVscyI6IHsKICAibWluaSI6IHsKICAgImlvcyI6IFsKICAgIHsKICAgICAicmVsZWFzZSI6ICIxLjIuMCIsCiAgICAgInVybCI6ICJodHRwczovL21vZGVscy5mbHVpZHZvaWNlLmFwcC9wYXJha2VldC9mbHVpZC1taW5pLzEuMi4wL21vZGVsLnppcCIsCiAgICAgImJ5dGVzIjogMjU0MTM2MzIwLAogICAgICJzaGEyNTYiOiAiYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYSIsCiAgICAgIm1hbmlmZXN0U0hBMjU2IjogImJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmIiLAogICAgICJmb3JtYXQiOiAxLAogICAgICJtaW5CdWlsZCI6IDEwCiAgICB9CiAgIF0sCiAgICJtYWNvcyI6IFtdCiAgfSwKICAicGljbyI6IHsKICAgImlvcyI6IFtdLAogICAibWFjb3MiOiBbXQogIH0KIH0KfQ==", "signature": "yovjDIsziFLloSNVV5QOImbtSc1eKm//rwPq8dYl0jdsD2VrNROe3+TnAXub8ipFRoAgfmxGCfocPnVvw1rqCA=="}\ No newline at end of filediff --git a/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/feeds/url-outside-prefix.json b/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/feeds/url-outside-prefix.jsonnew file mode 100644index 00000000..02780995--- /dev/null+++ b/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/feeds/url-outside-prefix.json@@ -0,0 +1 @@+{"payload": "ewogInNjaGVtYSI6IDEsCiAic2VxdWVuY2UiOiA3LAogIm1vZGVscyI6IHsKICAibWluaSI6IHsKICAgImlvcyI6IFsKICAgIHsKICAgICAicmVsZWFzZSI6ICIxLjIuMCIsCiAgICAgInVybCI6ICJodHRwczovL21vZGVscy5mbHVpZHZvaWNlLmFwcC9mZWVkL3YxL2ZsdWlkLXBhcmFrZWV0LW1pbmktY29yZW1sLnRhciIsCiAgICAgImJ5dGVzIjogMjU0MTM2MzIwLAogICAgICJzaGEyNTYiOiAiYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYSIsCiAgICAgIm1hbmlmZXN0U0hBMjU2IjogImJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmIiLAogICAgICJmb3JtYXQiOiAxLAogICAgICJtaW5CdWlsZCI6IDEwCiAgICB9CiAgIF0sCiAgICJtYWNvcyI6IFtdCiAgfSwKICAicGljbyI6IHsKICAgImlvcyI6IFtdLAogICAibWFjb3MiOiBbXQogIH0KIH0KfQ==", "signature": "0lc8RA3qkxwzYIVmtUhmCz8cXAZ77jo2al5geX4lr36ea99hmDzC7WySVYc2amdx41bQdqIm5ZTFweSsPX2PBQ=="}\ No newline at end of filediff --git a/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/feeds/url-port.json b/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/feeds/url-port.jsonnew file mode 100644index 00000000..9a8800c4--- /dev/null+++ b/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/feeds/url-port.json@@ -0,0 +1 @@+{"payload": "ewogInNjaGVtYSI6IDEsCiAic2VxdWVuY2UiOiA3LAogIm1vZGVscyI6IHsKICAibWluaSI6IHsKICAgImlvcyI6IFsKICAgIHsKICAgICAicmVsZWFzZSI6ICIxLjIuMCIsCiAgICAgInVybCI6ICJodHRwczovL21vZGVscy5mbHVpZHZvaWNlLmFwcDo4NDQzL3BhcmFrZWV0L2ZsdWlkLXBhcmFrZWV0LW1pbmktY29yZW1sLnRhciIsCiAgICAgImJ5dGVzIjogMjU0MTM2MzIwLAogICAgICJzaGEyNTYiOiAiYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYSIsCiAgICAgIm1hbmlmZXN0U0hBMjU2IjogImJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmIiLAogICAgICJmb3JtYXQiOiAxLAogICAgICJtaW5CdWlsZCI6IDEwCiAgICB9CiAgIF0sCiAgICJtYWNvcyI6IFtdCiAgfSwKICAicGljbyI6IHsKICAgImlvcyI6IFtdLAogICAibWFjb3MiOiBbXQogIH0KIH0KfQ==", "signature": "4UW8PapP3XaX0UaYROYILSkxlQHTFOAQdiFE98DwMjWBT7hs1r8nrC9qAvezxzjMDfR17OPWFfYWc6LpB0/ZAw=="}\ No newline at end of filediff --git a/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/feeds/url-query.json b/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/feeds/url-query.jsonnew file mode 100644index 00000000..fcc1003a--- /dev/null+++ b/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/feeds/url-query.json@@ -0,0 +1 @@+{"payload": "ewogInNjaGVtYSI6IDEsCiAic2VxdWVuY2UiOiA3LAogIm1vZGVscyI6IHsKICAibWluaSI6IHsKICAgImlvcyI6IFsKICAgIHsKICAgICAicmVsZWFzZSI6ICIxLjIuMCIsCiAgICAgInVybCI6ICJodHRwczovL21vZGVscy5mbHVpZHZvaWNlLmFwcC9wYXJha2VldC9mbHVpZC1wYXJha2VldC1taW5pLWNvcmVtbC50YXI/dj0yIiwKICAgICAiYnl0ZXMiOiAyNTQxMzYzMjAsCiAgICAgInNoYTI1NiI6ICJhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhIiwKICAgICAibWFuaWZlc3RTSEEyNTYiOiAiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYiIsCiAgICAgImZvcm1hdCI6IDEsCiAgICAgIm1pbkJ1aWxkIjogMTAKICAgIH0KICAgXSwKICAgIm1hY29zIjogW10KICB9LAogICJwaWNvIjogewogICAiaW9zIjogW10sCiAgICJtYWNvcyI6IFtdCiAgfQogfQp9", "signature": "9fwd8cZh4fasADdeEiYbgWCm7a+7uo7a+dZZmhqQzrdfLj4JSkpFhOu98LCrGkvT+E+EB006mB6VtZr6LcIAAg=="}\ No newline at end of filediff --git a/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/feeds/url-traversal.json b/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/feeds/url-traversal.jsonnew file mode 100644index 00000000..c782ab6d--- /dev/null+++ b/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/feeds/url-traversal.json@@ -0,0 +1 @@+{"payload": "ewogInNjaGVtYSI6IDEsCiAic2VxdWVuY2UiOiA3LAogIm1vZGVscyI6IHsKICAibWluaSI6IHsKICAgImlvcyI6IFsKICAgIHsKICAgICAicmVsZWFzZSI6ICIxLjIuMCIsCiAgICAgInVybCI6ICJodHRwczovL21vZGVscy5mbHVpZHZvaWNlLmFwcC9wYXJha2VldC8uLi9mZWVkL2ZsdWlkLXBhcmFrZWV0LW1pbmktY29yZW1sLnRhciIsCiAgICAgImJ5dGVzIjogMjU0MTM2MzIwLAogICAgICJzaGEyNTYiOiAiYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYSIsCiAgICAgIm1hbmlmZXN0U0hBMjU2IjogImJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmIiLAogICAgICJmb3JtYXQiOiAxLAogICAgICJtaW5CdWlsZCI6IDEwCiAgICB9CiAgIF0sCiAgICJtYWNvcyI6IFtdCiAgfSwKICAicGljbyI6IHsKICAgImlvcyI6IFtdLAogICAibWFjb3MiOiBbXQogIH0KIH0KfQ==", "signature": "vbR9/9KlEp3IDylymIGN/+B0MAe7Dg3/ZC4Czw99Pae6gbDw/zxsBasZ7Dp8H+rWbGBEvfLAVg6WSFCKAfkcBg=="}\ No newline at end of filediff --git a/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/feeds/url-user-info.json b/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/feeds/url-user-info.jsonnew file mode 100644index 00000000..02f47de1--- /dev/null+++ b/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/feeds/url-user-info.json@@ -0,0 +1 @@+{"payload": "ewogInNjaGVtYSI6IDEsCiAic2VxdWVuY2UiOiA3LAogIm1vZGVscyI6IHsKICAibWluaSI6IHsKICAgImlvcyI6IFsKICAgIHsKICAgICAicmVsZWFzZSI6ICIxLjIuMCIsCiAgICAgInVybCI6ICJodHRwczovL21vZGVscy5mbHVpZHZvaWNlLmFwcEBleGFtcGxlLmNvbS9wYXJha2VldC9mbHVpZC1wYXJha2VldC1taW5pLWNvcmVtbC50YXIiLAogICAgICJieXRlcyI6IDI1NDEzNjMyMCwKICAgICAic2hhMjU2IjogImFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWEiLAogICAgICJtYW5pZmVzdFNIQTI1NiI6ICJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiIiwKICAgICAiZm9ybWF0IjogMSwKICAgICAibWluQnVpbGQiOiAxMAogICAgfQogICBdLAogICAibWFjb3MiOiBbXQogIH0sCiAgInBpY28iOiB7CiAgICJpb3MiOiBbXSwKICAgIm1hY29zIjogW10KICB9CiB9Cn0=", "signature": "amcBHcDMUwPJTJxOAcH3Muf1dz7PbVL2b0AAa/aH5qfq8h6dtBqEUcRWU2cJ+j6+YAb8fXGp6vnd8VSFu3VqDg=="}\ No newline at end of filediff --git a/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/feeds/url-wrong-host.json b/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/feeds/url-wrong-host.jsonnew file mode 100644index 00000000..e06dc89d--- /dev/null+++ b/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/feeds/url-wrong-host.json@@ -0,0 +1 @@+{"payload": "ewogInNjaGVtYSI6IDEsCiAic2VxdWVuY2UiOiA3LAogIm1vZGVscyI6IHsKICAibWluaSI6IHsKICAgImlvcyI6IFsKICAgIHsKICAgICAicmVsZWFzZSI6ICIxLjIuMCIsCiAgICAgInVybCI6ICJodHRwczovL2V4YW1wbGUuY29tL3BhcmFrZWV0L2ZsdWlkLW1pbmkvMS4yLjAvZmx1aWQtcGFyYWtlZXQtbWluaS1jb3JlbWwudGFyIiwKICAgICAiYnl0ZXMiOiAyNTQxMzYzMjAsCiAgICAgInNoYTI1NiI6ICJhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhIiwKICAgICAibWFuaWZlc3RTSEEyNTYiOiAiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYiIsCiAgICAgImZvcm1hdCI6IDEsCiAgICAgIm1pbkJ1aWxkIjogMTAKICAgIH0KICAgXSwKICAgIm1hY29zIjogW10KICB9LAogICJwaWNvIjogewogICAiaW9zIjogW10sCiAgICJtYWNvcyI6IFtdCiAgfQogfQp9", "signature": "r4XWpuL5r4QFAm7cuVv6JibAtqw/FHhOr53smdMENYB6+STgSwgdkLGNY8PECifi6IvCXm6uqgERL/ufHwXQBg=="}\ No newline at end of filediff --git a/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/public_keys.json b/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/public_keys.jsonnew file mode 100644index 00000000..efa39d61--- /dev/null+++ b/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/public_keys.json@@ -0,0 +1,4 @@+{+ "main": "etCg9rPWJ81mB3XdJfKs2Y6QeuJjIIqCYfbYy40LRY4=",+ "spare": "Lf4aPkJzkEbu7nUj2Oh+ltoCePbPGXQMEMh+KfqtJvw="+}diff --git a/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/tars/absolute-path.tar b/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/tars/absolute-path.tarnew file mode 100644index 00000000..e9c7f0c3Binary files /dev/null and b/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/tars/absolute-path.tar differdiff --git a/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/tars/expected.json b/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/tars/expected.jsonnew file mode 100644index 00000000..74761e8e--- /dev/null+++ b/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/tars/expected.json@@ -0,0 +1,104 @@+[+ {+ "file": "good.tar",+ "folderName": "tiny-model",+ "manifestSHA256": "789c99ff3358b6f881cfccf2e3420533d9ede3145384e86a3a52f4225845416f",+ "verdict": "ok"+ },+ {+ "file": "pax.tar",+ "folderName": "tiny-model",+ "manifestSHA256": "789c99ff3358b6f881cfccf2e3420533d9ede3145384e86a3a52f4225845416f",+ "verdict": "unsafePath"+ },+ {+ "file": "tampered-file.tar",+ "folderName": "tiny-model",+ "manifestSHA256": "789c99ff3358b6f881cfccf2e3420533d9ede3145384e86a3a52f4225845416f",+ "verdict": "fileMismatch"+ },+ {+ "file": "wrong-size-file.tar",+ "folderName": "tiny-model",+ "manifestSHA256": "789c99ff3358b6f881cfccf2e3420533d9ede3145384e86a3a52f4225845416f",+ "verdict": "fileMismatch"+ },+ {+ "file": "missing-file.tar",+ "folderName": "tiny-model",+ "manifestSHA256": "789c99ff3358b6f881cfccf2e3420533d9ede3145384e86a3a52f4225845416f",+ "verdict": "fileMismatch"+ },+ {+ "file": "extra-file.tar",+ "folderName": "tiny-model",+ "manifestSHA256": "789c99ff3358b6f881cfccf2e3420533d9ede3145384e86a3a52f4225845416f",+ "verdict": "unlistedFile"+ },+ {+ "file": "other-manifest.tar",+ "folderName": "tiny-model",+ "manifestSHA256": "789c99ff3358b6f881cfccf2e3420533d9ede3145384e86a3a52f4225845416f",+ "verdict": "manifestMismatch"+ },+ {+ "file": "no-manifest.tar",+ "folderName": "tiny-model",+ "manifestSHA256": "789c99ff3358b6f881cfccf2e3420533d9ede3145384e86a3a52f4225845416f",+ "verdict": "manifestMismatch"+ },+ {+ "file": "wrong-total.tar",+ "folderName": "tiny-model",+ "manifestSHA256": "71481da01d303c2dea7fb7803d48f3d2b62c6ba6cce2f9977401862615cc5894",+ "verdict": "manifestMismatch"+ },+ {+ "file": "manifest-names-other-folder.tar",+ "folderName": "tiny-model",+ "manifestSHA256": "70ca01241180a231454f461947e8990d0b0762a5dfb37dd6c956df68758e0e32",+ "verdict": "manifestMismatch"+ },+ {+ "file": "manifest-path-escapes.tar",+ "folderName": "tiny-model",+ "manifestSHA256": "57ff9b64e417f067daf4d5a40456f91089d7a464af27b1face63716cdbf98145",+ "verdict": "fileMismatch"+ },+ {+ "file": "wrong-folder.tar",+ "folderName": "tiny-model",+ "manifestSHA256": "789c99ff3358b6f881cfccf2e3420533d9ede3145384e86a3a52f4225845416f",+ "verdict": "missingFolder"+ },+ {+ "file": "two-folders.tar",+ "folderName": "tiny-model",+ "manifestSHA256": "789c99ff3358b6f881cfccf2e3420533d9ede3145384e86a3a52f4225845416f",+ "verdict": "missingFolder"+ },+ {+ "file": "traversal.tar",+ "folderName": "tiny-model",+ "manifestSHA256": "789c99ff3358b6f881cfccf2e3420533d9ede3145384e86a3a52f4225845416f",+ "verdict": "unsafePath"+ },+ {+ "file": "absolute-path.tar",+ "folderName": "tiny-model",+ "manifestSHA256": "789c99ff3358b6f881cfccf2e3420533d9ede3145384e86a3a52f4225845416f",+ "verdict": "unsafePath"+ },+ {+ "file": "symlink.tar",+ "folderName": "tiny-model",+ "manifestSHA256": "789c99ff3358b6f881cfccf2e3420533d9ede3145384e86a3a52f4225845416f",+ "verdict": "unsupportedEntry"+ },+ {+ "file": "truncated.tar",+ "folderName": "tiny-model",+ "manifestSHA256": "789c99ff3358b6f881cfccf2e3420533d9ede3145384e86a3a52f4225845416f",+ "verdict": "truncatedArchive"+ }+]diff --git a/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/tars/extra-file.tar b/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/tars/extra-file.tarnew file mode 100644index 00000000..c9d9a88eBinary files /dev/null and b/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/tars/extra-file.tar differdiff --git a/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/tars/good.tar b/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/tars/good.tarnew file mode 100644index 00000000..18bed4a9Binary files /dev/null and b/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/tars/good.tar differdiff --git a/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/tars/manifest-names-other-folder.tar b/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/tars/manifest-names-other-folder.tarnew file mode 100644index 00000000..1a83ded0Binary files /dev/null and b/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/tars/manifest-names-other-folder.tar differdiff --git a/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/tars/manifest-path-escapes.tar b/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/tars/manifest-path-escapes.tarnew file mode 100644index 00000000..958b8493Binary files /dev/null and b/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/tars/manifest-path-escapes.tar differdiff --git a/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/tars/missing-file.tar b/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/tars/missing-file.tarnew file mode 100644index 00000000..8c61950eBinary files /dev/null and b/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/tars/missing-file.tar differdiff --git a/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/tars/no-manifest.tar b/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/tars/no-manifest.tarnew file mode 100644index 00000000..f8c58d53Binary files /dev/null and b/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/tars/no-manifest.tar differdiff --git a/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/tars/other-manifest.tar b/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/tars/other-manifest.tarnew file mode 100644index 00000000..2edff90bBinary files /dev/null and b/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/tars/other-manifest.tar differdiff --git a/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/tars/pax.tar b/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/tars/pax.tarnew file mode 100644index 00000000..94494ce5Binary files /dev/null and b/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/tars/pax.tar differdiff --git a/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/tars/symlink.tar b/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/tars/symlink.tarnew file mode 100644index 00000000..99ea6401Binary files /dev/null and b/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/tars/symlink.tar differdiff --git a/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/tars/tampered-file.tar b/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/tars/tampered-file.tarnew file mode 100644index 00000000..959d3cdcBinary files /dev/null and b/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/tars/tampered-file.tar differdiff --git a/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/tars/traversal.tar b/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/tars/traversal.tarnew file mode 100644index 00000000..42b8bb2aBinary files /dev/null and b/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/tars/traversal.tar differdiff --git a/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/tars/truncated.tar b/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/tars/truncated.tarnew file mode 100644index 00000000..7009347cBinary files /dev/null and b/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/tars/truncated.tar differdiff --git a/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/tars/two-folders.tar b/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/tars/two-folders.tarnew file mode 100644index 00000000..b2f59399Binary files /dev/null and b/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/tars/two-folders.tar differdiff --git a/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/tars/wrong-folder.tar b/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/tars/wrong-folder.tarnew file mode 100644index 00000000..ee38cf08Binary files /dev/null and b/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/tars/wrong-folder.tar differdiff --git a/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/tars/wrong-size-file.tar b/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/tars/wrong-size-file.tarnew file mode 100644index 00000000..b9c028a8Binary files /dev/null and b/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/tars/wrong-size-file.tar differdiff --git a/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/tars/wrong-total.tar b/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/tars/wrong-total.tarnew file mode 100644index 00000000..1375bbb4Binary files /dev/null and b/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/tars/wrong-total.tar differdiff --git a/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/test_key.json b/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/test_key.jsonnew file mode 100644index 00000000..a156189a--- /dev/null+++ b/Tests/FluidDictationIntegrationTests/Fixtures/ModelRelease/test_key.json@@ -0,0 +1,5 @@+{+ "note": "Test key for the fixtures only. It signs nothing real.",+ "seed": "Oet8Ql8/mQ/BxTkCkk1L+PE5O3ce3OS1mz3QmFl/BOw=",+ "publicKey": "hrWpkZUM4TP7ElDXPXRvSccJ6eOuZfsvItnbazb6Krs="+}diff --git a/Tests/FluidDictationIntegrationTests/HotkeyShortcutTests.swift b/Tests/FluidDictationIntegrationTests/HotkeyShortcutTests.swiftindex 0f08c6e9..f3d1f7b6 100644--- a/Tests/FluidDictationIntegrationTests/HotkeyShortcutTests.swift+++ b/Tests/FluidDictationIntegrationTests/HotkeyShortcutTests.swift@@ -646,7 +646,8 @@ final class HotkeyShortcutTests: XCTestCase {promptModeCallback: { starts += 1 },promptSelectionCallback: { _ in starts += 1 },commandModeCallback: { starts += 1 },- rewriteModeCallback: { starts += 1 }+ rewriteModeCallback: { starts += 1 },+ isSessionLockedProvider: { false })manager.setHotkeyMode(activationMode)let down = try self.primaryReleaseTestEvent(type: .keyDown)@@ -856,7 +857,8 @@ final class HotkeyShortcutTests: XCTestCase {promptModeCallback: { otherStarts += 1 },promptSelectionCallback: { _ in otherStarts += 1 },commandModeCallback: { otherStarts += 1 },- rewriteModeCallback: { otherStarts += 1 }+ rewriteModeCallback: { otherStarts += 1 },+ isSessionLockedProvider: { false })manager.setHotkeyMode(.toggle)_ = try manager.handleKeyEvent(type: .flagsChanged, event: self.primaryReleaseTestEvent(type: .flagsChanged, keyCode: 54, modifiers: .maskCommand))@@ -1031,7 +1033,8 @@ final class HotkeyShortcutTests: XCTestCase {promptModeCallback: { starts += 1 },promptSelectionCallback: { _ in starts += 1 },commandModeCallback: { starts += 1 },- rewriteModeCallback: { starts += 1 }+ rewriteModeCallback: { starts += 1 },+ isSessionLockedProvider: { false })manager.setHotkeyMode(.toggle)_ = try manager.handleKeyEvent(type: .flagsChanged, event: self.primaryReleaseTestEvent(type: .flagsChanged, keyCode: 54, modifiers: .maskCommand))@@ -1095,7 +1098,8 @@ final class HotkeyShortcutTests: XCTestCase {promptModeCallback: { starts += 1 },promptSelectionCallback: { _ in starts += 1 },commandModeCallback: { starts += 1 },- rewriteModeCallback: { starts += 1 }+ rewriteModeCallback: { starts += 1 },+ isSessionLockedProvider: { false })manager.setHotkeyMode(activation)let down = try self.primaryReleaseTestEvent(type: .keyDown, keyCode: 31, modifiers: [])@@ -1278,7 +1282,8 @@ final class HotkeyShortcutTests: XCTestCase {promptModeShortcutEnabled: false,commandModeShortcutEnabled: false,rewriteModeShortcutEnabled: false,- promptSelectionCallback: { selections.append($0) }+ promptSelectionCallback: { selections.append($0) },+ isSessionLockedProvider: { false })manager.setHotkeyMode(.toggle)_ = try manager.handleKeyEvent(type: .flagsChanged, event: self.primaryReleaseTestEvent(type: .flagsChanged, keyCode: 54, modifiers: .maskCommand))@@ -1330,7 +1335,8 @@ final class HotkeyShortcutTests: XCTestCase {startRecordingCallback: { starts += 1; asr.isRunning = true },dictationModeCallback: { starts += 1; asr.isRunning = true },stopAndProcessCallback: { _ in stops += 1 },- isDictateRecordingProvider: { isDictate }+ isDictateRecordingProvider: { isDictate },+ isSessionLockedProvider: { false })manager.setHotkeyMode(.hold)_ = try manager.handleKeyEvent(type: .flagsChanged, event: self.primaryReleaseTestEvent(type: .flagsChanged, keyCode: 55, modifiers: .maskCommand))@@ -1472,7 +1478,8 @@ final class HotkeyShortcutTests: XCTestCase {startRecordingCallback: { asr.isRunning = true },dictationModeCallback: { asr.isRunning = true },stopAndProcessCallback: { _ in stops += 1; asr.isRunning = false },- isDictateRecordingProvider: { isDictate }+ isDictateRecordingProvider: { isDictate },+ isSessionLockedProvider: { false })manager.setHotkeyMode(.hold)_ = try manager.handleKeyEvent(type: .keyDown, event: self.primaryReleaseTestEvent(type: .keyDown))@@ -1600,7 +1607,8 @@ final class HotkeyShortcutTests: XCTestCase {rewriteModeShortcutEnabled: false,stopAndProcessCallback: { _ in stops += 1; asr.isRunning = false },promptSelectionCallback: { _ in starts += 1; asr.isRunning = true },- isPromptModeRecordingProvider: { true }+ isPromptModeRecordingProvider: { true },+ isSessionLockedProvider: { false })manager.setHotkeyMode(.hold)_ = try manager.handleKeyEvent(type: .keyDown, event: self.primaryReleaseTestEvent(type: .keyDown, keyCode: 2, modifiers: .maskControl))@@ -1735,7 +1743,8 @@ final class HotkeyShortcutTests: XCTestCase {promptModeShortcutEnabled: false,commandModeShortcutEnabled: false,rewriteModeShortcutEnabled: false,- promptSelectionCallback: { selections.append($0) }+ promptSelectionCallback: { selections.append($0) },+ isSessionLockedProvider: { false })_ = try manager.handleKeyEvent(type: .keyDown, event: self.primaryReleaseTestEvent(type: .keyDown, modifiers: .maskControl))manager.updatePromptShortcutAssignments([(selection: .privateAI, shortcut: shortcut)])@@ -1772,7 +1781,8 @@ final class HotkeyShortcutTests: XCTestCase {stopAndProcessCallback: { _ in stops += 1; asr.isRunning = false },promptSelectionCallback: { _ in starts += 1; asr.isRunning = true },isDictateRecordingProvider: { !style },- isPromptModeRecordingProvider: { style }+ isPromptModeRecordingProvider: { style },+ isSessionLockedProvider: { false })manager.setHotkeyMode(.hold)_ = try manager.handleKeyEvent(type: .keyDown, event: self.primaryReleaseTestEvent(type: .keyDown, modifiers: .maskControl))@@ -1887,7 +1897,7 @@ final class HotkeyShortcutTests: XCTestCase {asr.isRunning = truedefer { asr.isRunning = false }var cancellations = 0- let manager = self.makePrimaryReleaseTestManager(asr: asr, onStart: {})+ let manager = self.makePrimaryReleaseTestManager(asr: asr, onStart: {}, isSessionLocked: { true })manager.setCancelCallback { cancellations += 1; return .cancelled }let result = try manager.handleKeyEvent(type: .keyDown, event: self.primaryReleaseTestEvent(type: .keyDown, keyCode: 53, modifiers: []))XCTAssertNil(result)@@ -2058,11 +2068,87 @@ final class HotkeyShortcutTests: XCTestCase {withExtendedLifetime(event) { XCTAssertNotNil(result) }}+ @MainActor+ func testLockedSessionBlocksPrimaryRecordingStarts() async throws {+ for activationMode in [HotkeyActivationMode.toggle, .hold, .automatic] {+ var starts = 0+ let manager = self.makePrimaryReleaseTestManager(asr: ASRService(), onStart: { starts += 1 }, isSessionLocked: { true })+ manager.setHotkeyMode(activationMode)+ _ = try manager.handleKeyEvent(type: .keyDown, event: self.primaryReleaseTestEvent(type: .keyDown))+ _ = try manager.handleKeyEvent(type: .keyUp, event: self.primaryReleaseTestEvent(type: .keyUp))+ for _ in 0..<20 {+ await Task.yield()+ }+ XCTAssertEqual(starts, 0, "A locked session must not start primary recording in \(activationMode)")+ }+ }++ @MainActor+ func testLockedSessionBlocksOtherRecordingStarts() async throws {+ let shortcut = HotkeyShortcut(keyCode: 2, modifierFlags: [.control, .command])+ for mode in [HotkeyHoldModeType.promptMode, .commandMode, .rewriteMode, .promptAssignment] {+ var starts = 0+ let manager = GlobalHotkeyManager(+ asrService: ASRService(),+ primaryShortcuts: [],+ promptModeShortcut: shortcut,+ commandModeShortcut: shortcut,+ rewriteModeShortcut: shortcut,+ promptShortcutAssignments: mode == .promptAssignment ? [(selection: SettingsStore.DictationPromptSelection.default, shortcut: shortcut)] : [],+ promptModeShortcutEnabled: mode == .promptMode,+ commandModeShortcutEnabled: mode == .commandMode,+ rewriteModeShortcutEnabled: mode == .rewriteMode,+ promptModeCallback: { starts += 1 },+ promptSelectionCallback: { _ in starts += 1 },+ commandModeCallback: { starts += 1 },+ rewriteModeCallback: { starts += 1 },+ isSessionLockedProvider: { true }+ )+ manager.setHotkeyMode(.toggle)+ _ = try manager.handleKeyEvent(type: .keyDown, event: self.primaryReleaseTestEvent(type: .keyDown))+ _ = try manager.handleKeyEvent(type: .keyUp, event: self.primaryReleaseTestEvent(type: .keyUp))+ for _ in 0..<20 {+ await Task.yield()+ }+ XCTAssertEqual(starts, 0, "A locked session must not start \(mode)")+ }+ }++ @MainActor+ func testLockingSessionStillAllowsOwnedHoldRelease() async throws {+ let asr = ASRService()+ defer { asr.isRunning = false }+ var isLocked = false+ var starts = 0+ var stops = 0+ let manager = self.makePrimaryReleaseTestManager(+ asr: asr,+ onStart: { starts += 1; asr.isRunning = true },+ onStop: { stops += 1; asr.isRunning = false },+ isSessionLocked: { isLocked }+ )+ manager.setHotkeyMode(.hold)+ _ = try manager.handleKeyEvent(type: .keyDown, event: self.primaryReleaseTestEvent(type: .keyDown))+ for _ in 0..<20 {+ await Task.yield()+ }+ XCTAssertEqual(starts, 1)+ XCTAssertTrue(asr.isRunning)+ isLocked = true+ _ = try manager.handleKeyEvent(type: .keyUp, event: self.primaryReleaseTestEvent(type: .keyUp, modifiers: []))+ for _ in 0..<20 {+ await Task.yield()+ }+ XCTAssertEqual(stops, 1, "Locking must not strand a recording owned by the held shortcut")+ XCTAssertFalse(asr.isRunning)+ }+@MainActorprivate func makePrimaryReleaseTestManager(asr: ASRService,onStart: @escaping () async -> Void,- onStop: @escaping () async -> Void = {}+ onStop: @escaping () async -> Void = {},+ isSessionLocked: @escaping () -> Bool = { false }) -> GlobalHotkeyManager {let manager = GlobalHotkeyManager(asrService: asr,@@ -2076,7 +2162,8 @@ final class HotkeyShortcutTests: XCTestCase {startRecordingCallback: onStart,dictationModeCallback: onStart,stopAndProcessCallback: { _ in await onStop() },- isDictateRecordingProvider: { true }+ isDictateRecordingProvider: { true },+ isSessionLockedProvider: isSessionLocked)manager.setHotkeyMode(.toggle)return managerdiff --git a/Tests/FluidDictationIntegrationTests/MeetingAutoDetectorTests.swift b/Tests/FluidDictationIntegrationTests/MeetingAutoDetectorTests.swiftindex cdd91866..595fb8b2 100644--- a/Tests/FluidDictationIntegrationTests/MeetingAutoDetectorTests.swift+++ b/Tests/FluidDictationIntegrationTests/MeetingAutoDetectorTests.swift@@ -109,7 +109,7 @@ private final class DetectorHarness {set { self.flags.browserEnabled = newValue }}- init() {+ init(rejectionLogger: @escaping (String) -> Void = { _ in }) {let flags = self.flagsself.detector = MeetingAutoDetector(workspaceEvents: self.workspace,@@ -120,7 +120,8 @@ private final class DetectorHarness {activityGate: self.gate,clock: self.clock,isNativeDetectionEnabled: { flags.nativeEnabled },- isBrowserDetectionEnabled: { flags.browserEnabled }+ isBrowserDetectionEnabled: { flags.browserEnabled },+ rejectionLogger: rejectionLogger)self.detector.onPromptRequested = { [weak self] request in self?.prompts.append(request) }self.detector.onStillRecordingNudge = { [weak self] in self?.nudges += 1 }@@ -795,7 +796,7 @@ final class MeetingAutoDetectorTests: XCTestCase {let h = DetectorHarness()let firstEpisode = h.confirmZoom()XCTAssertNotNil(firstEpisode)- h.detector.timeoutDismissed(episodeID: try XCTUnwrap(firstEpisode))+ try h.detector.timeoutDismissed(episodeID: XCTUnwrap(firstEpisode))// Window disappears; after grace + the 60s release window the episode is evicted.h.detector.handleWindowSnapshot([], at: h.clock.now())@@ -960,6 +961,65 @@ final class MeetingAutoDetectorTests: XCTestCase {XCTAssertEqual(h.prompts.first?.cta, .record)}+ func testRepeatedBusyEvidenceLogsOnceWithoutBlockingLaterPrompt() {+ var lines: [String] = []+ let h = DetectorHarness(rejectionLogger: { lines.append($0) })+ h.gate.isIdle = false+ h.confirmZoom()+ let target = h.detector.automaticTarget+ for _ in 0..<100 {+ h.detector.handleWindowSnapshot(+ [.init(processID: 100, windowID: 900, title: "Zoom Meeting", layer: 0)],+ at: h.clock.now()+ )+ }+ XCTAssertEqual(lines.filter { $0.contains("reason=busy") }.count, 1)+ XCTAssertTrue(h.prompts.isEmpty)+ XCTAssertEqual(h.detector.automaticTarget, target)+ h.gate.isIdle = true+ h.detector.handleWindowSnapshot(+ [.init(processID: 100, windowID: 900, title: "Zoom Meeting", layer: 0)],+ at: h.clock.now()+ )+ XCTAssertEqual(h.prompts.count, 1)+ XCTAssertEqual(h.prompts.first?.cta, .record)+ }++ func testRejectionLoggingResetsOnTerminationStopAndSleep() {+ var lines: [String] = []+ let h = DetectorHarness(rejectionLogger: { lines.append($0) })+ h.gate.isIdle = false+ h.confirmZoom()+ h.detector.handleWorkspaceEvent(.init(kind: .terminated, bundleIdentifier: "us.zoom.xos", processID: 100), at: h.clock.now())+ h.confirmZoom()+ XCTAssertEqual(lines.filter { $0.contains("reason=busy") }.count, 2)+ h.detector.stop()+ h.confirmZoom()+ XCTAssertEqual(lines.filter { $0.contains("reason=busy") }.count, 3)+ h.detector.disarmAndClearTransientState()+ h.confirmZoom()+ XCTAssertEqual(lines.filter { $0.contains("reason=busy") }.count, 4)+ XCTAssertTrue(h.prompts.isEmpty)+ }++ func testRejectionLoggingIsIndependentPerCandidateAndReason() {+ var lines: [String] = []+ let h = DetectorHarness(rejectionLogger: { lines.append($0) })+ h.gate.isIdle = false+ h.confirmZoom(pid: 100)+ h.confirmZoom(pid: 200)+ XCTAssertEqual(lines.filter { $0.contains("reason=busy") }.count, 2)+ h.advance(31)+ for _ in 0..<2 {+ h.detector.handleWindowSnapshot(+ [.init(processID: 200, windowID: 900, title: "Zoom Meeting", layer: 0)],+ at: h.clock.now()+ )+ }+ XCTAssertEqual(lines.filter { $0.contains("reason=deadline") }.count, 1)+ XCTAssertTrue(h.prompts.isEmpty)+ }+func testRedactedZoomUsesAXMeetingTitleEvenWhenWorkplaceComesFirst() async {let h = DetectorHarness()h.windowProvider.axTitles = ["Zoom Workplace", "Zoom Meeting"]diff --git a/Tests/FluidDictationIntegrationTests/MeetingProviderOptionsTests.swift b/Tests/FluidDictationIntegrationTests/MeetingProviderOptionsTests.swiftindex 35f23b91..f967c868 100644--- a/Tests/FluidDictationIntegrationTests/MeetingProviderOptionsTests.swift+++ b/Tests/FluidDictationIntegrationTests/MeetingProviderOptionsTests.swift@@ -27,6 +27,8 @@ final class MeetingProviderOptionsTests: XCTestCase {"parakeet-tdt-v3","parakeet-tdt-v99","whisper-tiny",+ "fluid-parakeet-mini",+ "fluid-parakeet-pico","",]for asrModel in unsupportedModels {@@ -172,7 +174,7 @@ final class MeetingProviderOptionsTests: XCTestCase {throw XCTSkip("Set FLUIDVOICE_MEETING_GERMAN_FIXTURE to a 16 kHz mono German WAV for model verification")}let file = try AVAudioFile(forReading: URL(fileURLWithPath: path), commonFormat: .pcmFormatFloat32, interleaved: false)- XCTAssertEqual(file.processingFormat.sampleRate, 16000)+ XCTAssertEqual(file.processingFormat.sampleRate, 16_000)XCTAssertEqual(file.processingFormat.channelCount, 1)let buffer = try XCTUnwrap(AVAudioPCMBuffer(pcmFormat: file.processingFormat, frameCapacity: AVAudioFrameCount(file.length)))try file.read(into: buffer)@@ -186,7 +188,7 @@ final class MeetingProviderOptionsTests: XCTestCase {XCTAssertTrue(output.result.text.lowercased().contains("morgen"))XCTAssertTrue(output.result.text.lowercased().contains("freitag"))XCTAssertFalse(output.words.isEmpty)- XCTAssertTrue(output.words.allSatisfy { $0.start >= 0 && $0.end >= $0.start && $0.end <= Double(samples.count) / 16000 + 0.1 })+ XCTAssertTrue(output.words.allSatisfy { $0.start >= 0 && $0.end >= $0.start && $0.end <= Double(samples.count) / 16_000 + 0.1 })XCTAssertEqual(SettingsStore.shared.selectedSpeechModel, selected)}#endifdiff --git a/Tests/FluidDictationIntegrationTests/MeetingRecoveryTests.swift b/Tests/FluidDictationIntegrationTests/MeetingRecoveryTests.swiftindex 005eb640..7d86c9f0 100644--- a/Tests/FluidDictationIntegrationTests/MeetingRecoveryTests.swift+++ b/Tests/FluidDictationIntegrationTests/MeetingRecoveryTests.swift@@ -1,6 +1,7 @@// Existing end-to-end fixture suite is kept together to share its setup and helpers.// swiftlint:disable file_lengthimport AppKit+import Combineimport CoreMedia@testable import FluidVoice_Debugimport Foundation@@ -11,6 +12,50 @@ import XCTest// Existing recovery suite shares setup across crash and corruption scenarios.// swiftlint:disable:next type_body_lengthfinal class MeetingRecoveryTests: XCTestCase {+ func testUnexpectedStopPublishesQuiescenceAfterDelayedAudioHandback() async throws {+ let dir = self.makeTempDirectory()+ defer { try? FileManager.default.removeItem(at: dir) }+ let store = MeetingSessionStore(rootDirectory: dir)+ let capture = StubCaptureController()+ capture.startResult = MeetingCaptureStartResult(+ tracks: [self.makeMicrophoneTrack(chunks: [])], firstPresentationTime: nil+ )+ let leasing = SuspendedHandbackASRActivityLeasing()+ defer { leasing.resumeHandback() }+ let coordinator = MeetingSessionCoordinator(+ store: store,+ capture: capture,+ processing: StubProcessingController(),+ audioArbiter: AudioActivityArbiter { leasing }+ )+ let session = try await coordinator.startRecording(configuration: self.makeConfiguration())+ capture.emit(.interrupted(kind: .captureStoppedUnexpectedly, trackID: nil, detail: "Fixture stop"))+ for _ in 0..<200 {+ if leasing.handbackStarted { break }+ try await Task.sleep(nanoseconds: 5_000_000)+ }+ XCTAssertTrue(leasing.handbackStarted, "Unexpected stop must reach audio handback")+ XCTAssertEqual(coordinator.state, .interrupted(session.id))+ XCTAssertFalse(coordinator.isQuiescent, "Retry/settings refresh must wait for handback")+ await self.drainCaptureEvents()+ var notifications = 0+ let subscription = coordinator.objectWillChange.sink { notifications += 1 }+ defer { subscription.cancel() }+ leasing.resumeHandback()+ for _ in 0..<200 {+ if coordinator.isQuiescent { break }+ try await Task.sleep(nanoseconds: 5_000_000)+ }+ XCTAssertTrue(coordinator.isQuiescent)+ XCTAssertGreaterThan(notifications, 0, "Views must be told when retry/settings refresh becomes safe")+ XCTAssertEqual(coordinator.state, .interrupted(session.id), "Completion must not restart recording")+ XCTAssertEqual(capture.startCount, 1)+ XCTAssertEqual(leasing.handbackCount, 1)+ let saved = try await store.load(id: session.id)+ XCTAssertEqual(saved?.state, .interrupted)+ XCTAssertTrue(saved?.failures.isEmpty == true)+ }+func testVoiceProcessingFallbackDoesNotDegradeHealthyRecording() async throws {for deliverDuringStart in [false, true] {let dir = self.makeTempDirectory()@@ -2468,19 +2513,113 @@ final class MeetingRecoveryTests: XCTestCase {try Data("{}".utf8).write(to: checkpointURL)XCTAssertTrue(FileManager.default.fileExists(atPath: checkpointURL.path))+ var lines: [String] = []let coordinator = MeetingSessionCoordinator(store: store,capture: StubCaptureController(),processing: StubProcessingController(),- audioArbiter: StubArbiter()+ audioArbiter: StubArbiter(),+ processingLogger: { lines.append($0) })await coordinator.ensureRestored()let result = try await coordinator.retryProcessing()+ XCTAssertEqual(lines.count, 1)+ XCTAssertTrue(lines.first?.contains("outcome=completed") == true)+ XCTAssertTrue(lines.first?.contains("stage=completed") == true)+ XCTAssertFalse(lines.first?.contains("errorCode=") == true)XCTAssertEqual(result.state, .completed)XCTAssertFalse(FileManager.default.fileExists(atPath: checkpointURL.path))}+ func testProcessingDiagnosticsPreserveFailureAndTranscriptAcrossRetries() async throws {+ let dir = self.makeTempDirectory()+ defer { try? FileManager.default.removeItem(at: dir) }+ let store = MeetingSessionStore(rootDirectory: dir)+ var session = self.makeCorrectionSession(state: .interrupted).session+ session.title = "Private meeting title"+ session.transcriptSegments[0].text = "Private transcript content"+ try await store.create(session)+ let message = "Missing model\n" + String(repeating: "x", count: 1000)+ let error = NSError(domain: "MeetingProbe\r", code: 42, userInfo: [NSLocalizedDescriptionKey: message])+ var lines: [String] = []+ let arbiter = StubArbiter()+ let processing = DiagnosticFailingProcessingController(error: error)+ let coordinator = MeetingSessionCoordinator(+ store: store,+ capture: StubCaptureController(),+ processing: processing,+ audioArbiter: arbiter,+ processingLogger: { lines.append($0) }+ )+ await coordinator.ensureRestored()+ for attempt in 1...2 {+ do {+ _ = try await coordinator.retryProcessing(sessionID: session.id)+ XCTFail("Expected the processing error")+ } catch {+ XCTAssertEqual((error as NSError).code, 42)+ }+ XCTAssertEqual(lines.count, attempt, "Exactly one terminal diagnostic per attempt")+ let line = try XCTUnwrap(lines.last)+ XCTAssertTrue(line.contains("outcome=failed"))+ XCTAssertTrue(line.contains("stage=transcribing"))+ XCTAssertTrue(line.contains("errorCode=MeetingProbe .42"))+ XCTAssertTrue(line.contains("elapsedMs="))+ XCTAssertLessThan(line.count, 800)+ XCTAssertFalse(line.contains("\n"))+ XCTAssertFalse(line.contains("\r"))+ XCTAssertFalse(line.contains(session.title))+ XCTAssertFalse(line.contains("Private transcript content"))+ let saved = try await store.load(id: session.id)+ let persisted = try XCTUnwrap(saved)+ XCTAssertEqual(persisted.state, .failed)+ XCTAssertEqual(persisted.failures.last?.message, message, "Only log details are shortened")+ XCTAssertEqual(persisted.transcriptSegments, session.transcriptSegments)+ XCTAssertEqual(persisted.audioTracks, session.audioTracks)+ XCTAssertEqual(arbiter.releaseCount, attempt)+ }+ XCTAssertEqual(arbiter.acquireCount, 2)+ processing.emitLateProgress(.completed)+ XCTAssertEqual(lines.count, 2, "Stale progress must not produce a second outcome")+ XCTAssertEqual(coordinator.activeSession?.state, .failed)+ XCTAssertEqual(coordinator.activeSession?.transcriptSegments, session.transcriptSegments)+ }++ func testProcessingCancellationLogsWithoutAddingFailureOrLosingTranscript() async throws {+ let dir = self.makeTempDirectory()+ defer { try? FileManager.default.removeItem(at: dir) }+ let store = MeetingSessionStore(rootDirectory: dir)+ let session = self.makeCorrectionSession(state: .interrupted).session+ try await store.create(session)+ var lines: [String] = []+ let arbiter = StubArbiter()+ let coordinator = MeetingSessionCoordinator(+ store: store,+ capture: StubCaptureController(),+ processing: DiagnosticFailingProcessingController(error: CancellationError()),+ audioArbiter: arbiter,+ processingLogger: { lines.append($0) }+ )+ await coordinator.ensureRestored()+ do {+ _ = try await coordinator.retryProcessing(sessionID: session.id)+ XCTFail("Expected cancellation")+ } catch {+ XCTAssertTrue(error is CancellationError)+ }+ XCTAssertEqual(lines.count, 1)+ XCTAssertTrue(lines.first?.contains("outcome=cancelled") == true)+ XCTAssertFalse(lines.first?.contains("errorCode=") == true)+ let saved = try await store.load(id: session.id)+ let persisted = try XCTUnwrap(saved)+ XCTAssertEqual(persisted.state, .interrupted)+ XCTAssertTrue(persisted.failures.isEmpty)+ XCTAssertEqual(persisted.transcriptSegments, session.transcriptSegments)+ XCTAssertEqual(persisted.audioTracks, session.audioTracks)+ XCTAssertEqual(arbiter.releaseCount, 1)+ }+// MARK: - Slice 3, test 4: checkpoint survives a failed retryfunc testCheckpointSurvivesProcessingFailure() async throws {@@ -4783,6 +4922,27 @@ private final class StubProcessingController: MeetingProcessingControlling {}}+@MainActor+private final class DiagnosticFailingProcessingController: MeetingProcessingControlling {+ private let error: Error+ private var lastProgress: (@MainActor (MeetingProcessingStage) -> Void)?++ init(error: Error) { self.error = error }++ func emitLateProgress(_ stage: MeetingProcessingStage) { self.lastProgress?(stage) }++ func process(+ session: MeetingSession,+ sessionDirectory: URL,+ progress: @escaping @MainActor (MeetingProcessingStage) -> Void+ ) async throws -> MeetingProcessingResult {+ self.lastProgress = progress+ progress(.identifyingSpeakers)+ progress(.transcribing)+ throw self.error+ }+}+private struct ProcessingFailure: Error {}@MainActor@@ -4873,12 +5033,13 @@ private final class GatedProcessingController: MeetingProcessingControlling {@MainActorprivate final class StubArbiter: MeetingAudioActivityArbitrating {private(set) var acquireCount = 0+ private(set) var releaseCount = 0func acquireMeetingCapture() async throws -> MeetingAudioActivityLease {self.acquireCount += 1return MeetingAudioActivityLease(id: UUID())}- func release(_ lease: MeetingAudioActivityLease) async {}+ func release(_ lease: MeetingAudioActivityLease) async { self.releaseCount += 1 }}/// Records acquire/release calls without touching a real ASRService.diff --git a/Tests/FluidDictationIntegrationTests/ParakeetArchiveDownloaderTests.swift b/Tests/FluidDictationIntegrationTests/ParakeetArchiveDownloaderTests.swiftnew file mode 100644index 00000000..81c42d34--- /dev/null+++ b/Tests/FluidDictationIntegrationTests/ParakeetArchiveDownloaderTests.swift@@ -0,0 +1,871 @@+import CryptoKit+import Darwin+@testable import FluidVoice_Debug+import Foundation+import XCTest++final nonisolated class ParakeetArchiveDownloaderTests: XCTestCase {+ func testValidTarPublishesCompleteModelWithRealByteProgressAndPreservesSiblings() async throws {+ let fixture = try Fixture()+ defer { fixture.cleanup() }+ let recorder = ProgressRecorder()+ let result = try await fixture.install(progress: recorder.record)+ XCTAssertEqual(result, fixture.target)+ XCTAssertTrue(ParakeetArchiveDownloader.artifactsAreComplete(at: result, descriptor: fixture.descriptor))+ XCTAssertTrue(fixture.descriptor.artifactsAreComplete(at: result))+ XCTAssertEqual(try Data(contentsOf: result.appendingPathComponent(ParakeetSpeechModelCatalog.installationRevisionFileName)), try Data(XCTUnwrap(fixture.descriptor.archiveSHA256).utf8))+ XCTAssertEqual(recorder.values.filter { $0.phase == .downloading }.compactMap(\.fractionCompleted), [0.5, 1])+ XCTAssertEqual(recorder.values.last?.phase, .loading)+ try fixture.assertPreservedSiblingsAndNoStage()+ }++ func testInstalledCompleteCacheSkipsNetwork() async throws {+ let fixture = try Fixture()+ defer { fixture.cleanup() }+ _ = try await fixture.install()+ let result = try await ParakeetArchiveDownloader.ensurePresent(descriptor: fixture.descriptor, in: fixture.models, transport: { _, _ in+ XCTFail("An installed model must not use the network")+ throw ProbeFailure.injected+ })+ XCTAssertEqual(result, fixture.target)+ try fixture.assertPreservedSiblingsAndNoStage()+ }++ func testNewRevisionRejectsOldCompleteCacheAndPublishesOnlyAfterOwnedRemoval() async throws {+ let old = try Fixture()+ let newer = try Fixture(artifactContents: "new trained checkpoint")+ defer { old.cleanup(); newer.cleanup() }+ _ = try await old.install()+ XCTAssertTrue(old.descriptor.artifactsAreComplete(at: old.target))+ XCTAssertFalse(newer.descriptor.artifactsAreComplete(at: old.target))+ XCTAssertFalse(ParakeetArchiveDownloader.artifactsAreComplete(at: old.target, descriptor: newer.descriptor))+ do {+ _ = try await ParakeetArchiveDownloader.ensurePresent(descriptor: newer.descriptor, in: old.models, transport: { _, _ in+ XCTFail("The downloader must preserve an existing target until its caller admits removal")+ throw ProbeFailure.injected+ })+ XCTFail("An old revision must never be accepted as the new installed model")+ } catch let error as ParakeetArchiveDownloader.DownloadError {+ guard case .targetExists = error else { return XCTFail("Expected actionable existing-cache failure") }+ }+ XCTAssertTrue(old.descriptor.artifactsAreComplete(at: old.target))+ // Mirror the provider's admitted removal of this exact stale model folder.+ // The archive helper itself never removes an existing installed target.+ try FileManager.default.removeItem(at: old.target)+ let result = try await ParakeetArchiveDownloader.ensurePresent(descriptor: newer.descriptor, in: old.models, transport: { _, progress in+ try newer.transport(progress)+ })+ XCTAssertEqual(result, old.target)+ XCTAssertTrue(newer.descriptor.artifactsAreComplete(at: result))+ XCTAssertFalse(old.descriptor.artifactsAreComplete(at: result))+ try old.assertPreservedSiblingsAndNoStage()+ try newer.assertPreservedSiblingsAndNoStage()+ }++ func testMissingWrongOversizedAndSymlinkRevisionMarkersCannotClaimInstalledCache() async throws {+ let fixture = try Fixture()+ defer { fixture.cleanup() }+ _ = try await fixture.install()+ let marker = fixture.target.appendingPathComponent(ParakeetSpeechModelCatalog.installationRevisionFileName)+ for contents: Data? in [nil, Data(String(repeating: "0", count: 64).utf8), Data(repeating: 1, count: 65)] {+ try FileManager.default.removeItem(at: marker)+ if let contents { try contents.write(to: marker) }+ XCTAssertFalse(fixture.descriptor.artifactsAreComplete(at: fixture.target))+ XCTAssertFalse(ParakeetArchiveDownloader.artifactsAreComplete(at: fixture.target, descriptor: fixture.descriptor))+ if contents == nil { try fixture.descriptor.writeInstallationRevision(at: fixture.target) }+ }+ try FileManager.default.removeItem(at: marker)+ let external = fixture.base.appendingPathComponent("external-revision")+ try Data(XCTUnwrap(fixture.descriptor.archiveSHA256).utf8).write(to: external)+ try FileManager.default.createSymbolicLink(at: marker, withDestinationURL: external)+ XCTAssertFalse(fixture.descriptor.artifactsAreComplete(at: fixture.target))+ XCTAssertFalse(ParakeetArchiveDownloader.artifactsAreComplete(at: fixture.target, descriptor: fixture.descriptor))+ XCTAssertTrue(ParakeetSpeechModelCatalog.v2.installationRevisionMatches(at: fixture.base))+ XCTAssertTrue(ParakeetSpeechModelCatalog.v3.installationRevisionMatches(at: fixture.base))+ try fixture.assertPreservedSiblingsAndNoStage()+ }++ func testExplicitUpdateValidatesUnpublishedStageThenSwapsAndRemovesOldFiles() async throws {+ let old = try Fixture()+ let newer = try Fixture(artifactContents: "new trained checkpoint")+ defer { old.cleanup(); newer.cleanup() }+ _ = try await old.install()+ let result = try await ParakeetArchiveDownloader.ensurePresent(+ descriptor: newer.descriptor,+ in: old.models,+ replaceExisting: true,+ stageValidator: { stage in+ XCTAssertNotEqual(stage, old.target)+ XCTAssertTrue(newer.descriptor.artifactsAreComplete(at: stage))+ XCTAssertTrue(old.descriptor.artifactsAreComplete(at: old.target), "Old weights stay usable during validation")+ }, transport: { _, progress in try newer.transport(progress) }+ )+ XCTAssertEqual(result, old.target)+ XCTAssertTrue(newer.descriptor.artifactsAreComplete(at: result))+ XCTAssertFalse(old.descriptor.artifactsAreComplete(at: result))+ XCTAssertEqual(try String(contentsOf: result.appendingPathComponent("Encoder-1.mlmodelc/weights/weight.bin"), encoding: .utf8), "new trained checkpoint")+ try old.assertPreservedSiblingsAndNoStage()+ try newer.assertPreservedSiblingsAndNoStage()+ }++ func testUpdateValidatorFailureAndCancellationPreserveInstalledOldRevision() async throws {+ for cancel in [false, true] {+ let old = try Fixture()+ let newer = try Fixture(artifactContents: "new trained checkpoint")+ defer { old.cleanup(); newer.cleanup() }+ _ = try await old.install()+ do {+ _ = try await ParakeetArchiveDownloader.ensurePresent(+ descriptor: newer.descriptor,+ in: old.models,+ replaceExisting: true,+ stageValidator: { _ in+ if cancel { withUnsafeCurrentTask { $0?.cancel() } } else { throw ProbeFailure.injected }+ }, transport: { _, progress in try newer.transport(progress) }+ )+ XCTFail("Failed or cancelled Core ML validation must not publish")+ } catch {}+ XCTAssertTrue(old.descriptor.artifactsAreComplete(at: old.target))+ XCTAssertEqual(try String(contentsOf: old.target.appendingPathComponent("Encoder-1.mlmodelc/weights/weight.bin"), encoding: .utf8), "fixture")+ try old.assertPreservedSiblingsAndNoStage()+ try newer.assertPreservedSiblingsAndNoStage()+ }+ }++ func testUpdateTransferFailureAndBadChecksumPreserveOldFiles() async throws {+ for badChecksum in [false, true] {+ let old = try Fixture()+ let newer = try Fixture(checksum: badChecksum ? String(repeating: "0", count: 64) : nil, artifactContents: "new trained checkpoint")+ defer { old.cleanup(); newer.cleanup() }+ _ = try await old.install()+ await self.expectFailure {+ _ = try await ParakeetArchiveDownloader.ensurePresent(descriptor: newer.descriptor, in: old.models, replaceExisting: true, transport: { _, progress in+ if !badChecksum { throw ProbeFailure.injected }+ return try newer.transport(progress)+ })+ }+ XCTAssertTrue(old.descriptor.artifactsAreComplete(at: old.target))+ try old.assertPreservedSiblingsAndNoStage()+ try newer.assertPreservedSiblingsAndNoStage()+ }+ }++ func testUpdateCancellationDuringTransferKeepsOldModel() async throws {+ let old = try Fixture()+ let newer = try Fixture(artifactContents: "new trained checkpoint")+ defer { old.cleanup(); newer.cleanup() }+ _ = try await old.install()+ let started = Started()+ let task = Task {+ try await ParakeetArchiveDownloader.ensurePresent(descriptor: newer.descriptor, in: old.models, replaceExisting: true, transport: { _, _ in+ await started.signal()+ try await Task.sleep(for: .seconds(30))+ throw ProbeFailure.injected+ })+ }+ await started.wait()+ task.cancel()+ do { _ = try await task.value; XCTFail("Expected cancellation") } catch is CancellationError {} catch { XCTFail("Unexpected error: \(error)") }+ XCTAssertTrue(old.descriptor.artifactsAreComplete(at: old.target))+ try old.assertPreservedSiblingsAndNoStage()+ }++ func testUpdateIncompleteArchivePreservesOldModel() async throws {+ let old = try Fixture()+ let newer = try Fixture(omitLastArtifact: true, artifactContents: "new trained checkpoint")+ defer { old.cleanup(); newer.cleanup() }+ _ = try await old.install()+ await self.expectFailure {+ _ = try await ParakeetArchiveDownloader.ensurePresent(descriptor: newer.descriptor, in: old.models, replaceExisting: true, transport: { _, progress in try newer.transport(progress) })+ }+ XCTAssertTrue(old.descriptor.artifactsAreComplete(at: old.target))+ try old.assertPreservedSiblingsAndNoStage()+ try newer.assertPreservedSiblingsAndNoStage()+ }++ func testCancellationAtCompletedArchiveHandoffCleansReadyAndKeepsOldModel() async throws {+ let old = try Fixture()+ let newer = try Fixture(artifactContents: "new trained checkpoint")+ defer { old.cleanup(); newer.cleanup() }+ _ = try await old.install()+ let directory = old.models.appendingPathComponent(".compact-downloads/\(newer.descriptor.folderName)", isDirectory: true)+ try FileManager.default.createDirectory(at: directory, withIntermediateDirectories: true)+ let ready = directory.appendingPathComponent("ready-\(getpid())-\(UUID().uuidString).tar")+ do {+ _ = try await ParakeetArchiveDownloader.ensurePresent(+ descriptor: newer.descriptor,+ in: old.models,+ replaceExisting: true,+ transport: { url, _ in+ try newer.archive.write(to: ready)+ let response = try XCTUnwrap(HTTPURLResponse(url: url, statusCode: 200, httpVersion: nil, headerFields: nil))+ // Cancel after a completed handoff exists, before its URL reaches+ // the installer's first cancellation check.+ withUnsafeCurrentTask { $0?.cancel() }+ return (ready, response)+ }+ )+ XCTFail("Expected cancellation at the completed archive handoff")+ } catch is CancellationError {} catch { XCTFail("Expected CancellationError, got \(error)") }+ XCTAssertFalse(FileManager.default.fileExists(atPath: ready.path))+ XCTAssertTrue(old.descriptor.artifactsAreComplete(at: old.target))+ XCTAssertEqual(try String(contentsOf: old.target.appendingPathComponent("Encoder-1.mlmodelc/weights/weight.bin"), encoding: .utf8), "fixture")+ try old.assertPreservedSiblingsAndNoStage()+ try newer.assertPreservedSiblingsAndNoStage()+ }++ func testCompetingUpdatesPublishOnceAndRejectStaleOriginalIdentity() async throws {+ let old = try Fixture()+ let newer = try Fixture(artifactContents: "new trained checkpoint")+ defer { old.cleanup(); newer.cleanup() }+ _ = try await old.install()+ let gate = UpdateValidationGate()+ let operation: @Sendable () async throws -> Bool = {+ do {+ _ = try await ParakeetArchiveDownloader.ensurePresent(+ descriptor: newer.descriptor,+ in: old.models,+ replaceExisting: true,+ stageValidator: { _ in await gate.enter() },+ transport: { _, progress in try newer.transport(progress) }+ )+ return true+ } catch let error as ParakeetArchiveDownloader.DownloadError {+ guard case .targetChanged = error else { throw error }+ return false+ }+ }+ let first = Task { try await operation() }+ let second = Task { try await operation() }+ let deadline = ContinuousClock.now + .seconds(3)+ while await gate.count < 2, ContinuousClock.now < deadline {+ try await Task.sleep(for: .milliseconds(1))+ }+ let arrived = await gate.count+ await gate.releaseAll()+ XCTAssertEqual(arrived, 2, "Both stages must validate before either publishes")+ let results = try await [first.value, second.value]+ XCTAssertEqual(results.filter { $0 }.count, 1)+ XCTAssertTrue(newer.descriptor.artifactsAreComplete(at: old.target))+ try old.assertPreservedSiblingsAndNoStage()+ try newer.assertPreservedSiblingsAndNoStage()+ }++ func testPostCommitCleanupFailureReportsInstalledNewAndRetainedOldFiles() async throws {+ guard geteuid() != 0 else { throw XCTSkip("Filesystem permission failure requires a non-root user") }+ let old = try Fixture()+ let newer = try Fixture(artifactContents: "new trained checkpoint")+ defer { old.cleanup(); newer.cleanup() }+ _ = try await old.install()+ do {+ _ = try await ParakeetArchiveDownloader.ensurePresent(+ descriptor: newer.descriptor,+ in: old.models,+ replaceExisting: true,+ stageValidator: { stage in+ let ownedStage = stage.deletingLastPathComponent().deletingLastPathComponent()+ try FileManager.default.setAttributes([.posixPermissions: 0o500], ofItemAtPath: ownedStage.path)+ }, transport: { _, progress in try newer.transport(progress) }+ )+ XCTFail("Cleanup failure must not be returned as success")+ } catch let error as ParakeetArchiveDownloader.DownloadError {+ guard case let .replacementCleanupFailed(installed, retainedOld) = error else { return XCTFail("Expected post-commit cleanup failure, got \(error)") }+ XCTAssertEqual(installed, old.target)+ XCTAssertTrue(newer.descriptor.artifactsAreComplete(at: installed))+ XCTAssertTrue(FileManager.default.fileExists(atPath: retainedOld.path), "A post-commit cleanup error names the owned remainder, not a rollback")+ try FileManager.default.setAttributes([.posixPermissions: 0o700], ofItemAtPath: retainedOld.path)+ try FileManager.default.removeItem(at: retainedOld)+ }+ try old.assertPreservedSiblingsAndNoStage()+ try newer.assertPreservedSiblingsAndNoStage()+ }++ func testUpdateCleanupFailureNamesRetainedArchiveWhenStageRemovalSucceeds() async throws {+ guard geteuid() != 0 else { throw XCTSkip("Filesystem permission failure requires a non-root user") }+ let old = try Fixture()+ let newer = try Fixture(artifactContents: "new trained checkpoint")+ let directory = newer.base.appendingPathComponent("owned-ready", isDirectory: true)+ defer {+ try? FileManager.default.setAttributes([.posixPermissions: 0o700], ofItemAtPath: directory.path)+ old.cleanup()+ newer.cleanup()+ }+ _ = try await old.install()+ try FileManager.default.createDirectory(at: directory, withIntermediateDirectories: false)+ let ready = directory.appendingPathComponent("archive.tar")+ do {+ _ = try await ParakeetArchiveDownloader.ensurePresent(+ descriptor: newer.descriptor,+ in: old.models,+ replaceExisting: true,+ transport: { url, _ in+ try newer.archive.write(to: ready)+ try FileManager.default.setAttributes([.posixPermissions: 0o500], ofItemAtPath: directory.path)+ // Reject this handoff before moving it into staging. Its parent+ // blocks archive deletion while the independent stage can be removed.+ return try (ready, XCTUnwrap(HTTPURLResponse(url: url, statusCode: 500, httpVersion: nil, headerFields: nil)))+ }+ )+ XCTFail("Expected an update failure with retained archive cleanup")+ } catch let error as ParakeetArchiveDownloader.DownloadError {+ guard case let .updateFailedWithCleanup(_, installed, temporaryFiles) = error else {+ return XCTFail("Expected failed-update cleanup error, got \(error)")+ }+ XCTAssertEqual(installed, old.target)+ XCTAssertEqual(temporaryFiles, ready)+ XCTAssertTrue(FileManager.default.fileExists(atPath: temporaryFiles.path))+ }+ XCTAssertTrue(old.descriptor.artifactsAreComplete(at: old.target))+ XCTAssertEqual(try String(contentsOf: old.target.appendingPathComponent("Encoder-1.mlmodelc/weights/weight.bin"), encoding: .utf8), "fixture")+ try old.assertPreservedSiblingsAndNoStage()+ try newer.assertPreservedSiblingsAndNoStage()+ }++ func testUpdateRejectsChangedTargetIdentityEvenWithTheSameRevision() async throws {+ let old = try Fixture()+ let newer = try Fixture(artifactContents: "new trained checkpoint")+ defer { old.cleanup(); newer.cleanup() }+ _ = try await old.install()+ do {+ _ = try await ParakeetArchiveDownloader.ensurePresent(+ descriptor: newer.descriptor,+ in: old.models,+ replaceExisting: true,+ stageValidator: { _ in+ let replacement = old.models.appendingPathComponent("competing-target")+ try FileManager.default.copyItem(at: old.target, to: replacement)+ try FileManager.default.removeItem(at: old.target)+ try FileManager.default.moveItem(at: replacement, to: old.target)+ }, transport: { _, progress in try newer.transport(progress) }+ )+ XCTFail("A replaced directory must not be overwritten")+ } catch let error as ParakeetArchiveDownloader.DownloadError {+ guard case .targetChanged = error else { return XCTFail("Expected targetChanged") }+ }+ XCTAssertTrue(old.descriptor.artifactsAreComplete(at: old.target))+ try old.assertPreservedSiblingsAndNoStage()+ }++ func testUpdateRejectsRevisionChangedDuringValidation() async throws {+ let old = try Fixture()+ let newer = try Fixture(artifactContents: "new trained checkpoint")+ defer { old.cleanup(); newer.cleanup() }+ _ = try await old.install()+ let competingHash = String(repeating: "a", count: 64)+ do {+ _ = try await ParakeetArchiveDownloader.ensurePresent(+ descriptor: newer.descriptor,+ in: old.models,+ replaceExisting: true,+ stageValidator: { _ in+ try Data(competingHash.utf8).write(to: old.target.appendingPathComponent(ParakeetSpeechModelCatalog.installationRevisionFileName))+ }, transport: { _, progress in try newer.transport(progress) }+ )+ XCTFail("A changed checkpoint must be preserved")+ } catch let error as ParakeetArchiveDownloader.DownloadError {+ guard case .targetChanged = error else { return XCTFail("Expected targetChanged") }+ }+ XCTAssertEqual(old.descriptor.installedArchiveSHA256(at: old.target), competingHash)+ try old.assertPreservedSiblingsAndNoStage()+ }++ func testRevisionWriteFailureCleansStageAndNeverPublishes() async throws {+ let fixture = try Fixture()+ defer { fixture.cleanup() }+ await self.expectFailure {+ _ = try await ParakeetArchiveDownloader.ensurePresent(+ descriptor: fixture.descriptor,+ in: fixture.models,+ transport: { _, progress in try fixture.transport(progress) },+ revisionWriter: { _, _ in throw CocoaError(.fileWriteNoPermission) }+ )+ }+ XCTAssertFalse(FileManager.default.fileExists(atPath: fixture.target.path))+ try fixture.assertPreservedSiblingsAndNoStage()+ }++ func testCancellationAfterRevisionWriteCleansStageWithoutPublishing() async throws {+ let fixture = try Fixture()+ defer { fixture.cleanup() }+ do {+ _ = try await ParakeetArchiveDownloader.ensurePresent(+ descriptor: fixture.descriptor,+ in: fixture.models,+ transport: { _, progress in try fixture.transport(progress) },+ revisionWriter: { directory, descriptor in+ try descriptor.writeInstallationRevision(at: directory)+ withUnsafeCurrentTask { $0?.cancel() }+ }+ )+ XCTFail("Expected cancellation before publication")+ } catch is CancellationError {} catch { XCTFail("Expected CancellationError, got \(error)") }+ XCTAssertFalse(FileManager.default.fileExists(atPath: fixture.target.path))+ try fixture.assertPreservedSiblingsAndNoStage()+ }++ func testArchiveCannotSupplyItsOwnRevisionMarker() async throws {+ let marker = "fluid-parakeet-mini-coreml/" + ParakeetSpeechModelCatalog.installationRevisionFileName+ let fixture = try Fixture(extraEntry: Entry(path: marker, data: Data(String(repeating: "0", count: 64).utf8)))+ defer { fixture.cleanup() }+ await self.expectFailure { _ = try await fixture.install() }+ XCTAssertFalse(FileManager.default.fileExists(atPath: fixture.target.path))+ try fixture.assertPreservedSiblingsAndNoStage()+ }++ func testWrongHashDoesNotExtractOrPublish() async throws {+ let fixture = try Fixture(checksum: String(repeating: "0", count: 64))+ defer { fixture.cleanup() }+ await self.expectFailure { _ = try await fixture.install() }+ XCTAssertFalse(FileManager.default.fileExists(atPath: fixture.target.path))+ try fixture.assertPreservedSiblingsAndNoStage()+ }++ func testMissingCompiledArtifactDoesNotPublish() async throws {+ let fixture = try Fixture(omitLastArtifact: true)+ defer { fixture.cleanup() }+ await self.expectFailure { _ = try await fixture.install() }+ XCTAssertFalse(FileManager.default.fileExists(atPath: fixture.target.path))+ try fixture.assertPreservedSiblingsAndNoStage()+ }++ func testWrongArchiveRootCannotWriteASibling() async throws {+ let fixture = try Fixture(rootName: "parakeet-tdt-0.6b-v3-coreml")+ defer { fixture.cleanup() }+ await self.expectFailure { _ = try await fixture.install() }+ XCTAssertFalse(FileManager.default.fileExists(atPath: fixture.target.path))+ try fixture.assertPreservedSiblingsAndNoStage()+ }++ func testTraversalAndSymlinkEntriesAreRejected() async throws {+ for entry in [Entry(path: "../escape", data: Data("bad".utf8)), Entry(path: "fluid-parakeet-mini-coreml/link", type: 50)] {+ let fixture = try Fixture(extraEntry: entry)+ defer { fixture.cleanup() }+ await self.expectFailure { _ = try await fixture.install() }+ XCTAssertFalse(FileManager.default.fileExists(atPath: fixture.target.path))+ XCTAssertFalse(FileManager.default.fileExists(atPath: fixture.base.appendingPathComponent("escape").path))+ try fixture.assertPreservedSiblingsAndNoStage()+ }+ }++ func testCancellationDuringTransferCleansOwnedStageAndPreservesSiblings() async throws {+ let fixture = try Fixture()+ defer { fixture.cleanup() }+ let started = Started()+ let task = Task {+ try await ParakeetArchiveDownloader.ensurePresent(descriptor: fixture.descriptor, in: fixture.models, transport: { _, _ in+ await started.signal()+ try await Task.sleep(for: .seconds(30))+ throw ProbeFailure.injected+ })+ }+ await started.wait()+ task.cancel()+ do {+ _ = try await task.value+ XCTFail("Expected transfer cancellation")+ } catch is CancellationError {} catch { XCTFail("Expected CancellationError, got \(error)") }+ XCTAssertFalse(FileManager.default.fileExists(atPath: fixture.target.path))+ try fixture.assertPreservedSiblingsAndNoStage()+ }++ func testCancellationAfterHashBeforeExtractionNeverExposesPartialTarget() async throws {+ let fixture = try Fixture()+ defer { fixture.cleanup() }+ do {+ _ = try await fixture.install(progress: { progress in+ if progress.phase == .optimizing { withUnsafeCurrentTask { $0?.cancel() } }+ })+ XCTFail("Expected install cancellation")+ } catch is CancellationError {} catch { XCTFail("Expected CancellationError, got \(error)") }+ XCTAssertFalse(FileManager.default.fileExists(atPath: fixture.target.path))+ try fixture.assertPreservedSiblingsAndNoStage()+ }++ func testExistingIncompleteTargetAndCompetingPublishedTargetAreNeverOverwritten() async throws {+ let fixture = try Fixture()+ defer { fixture.cleanup() }+ try FileManager.default.createDirectory(at: fixture.target, withIntermediateDirectories: false)+ let marker = fixture.target.appendingPathComponent("keep")+ try Data("keep".utf8).write(to: marker)+ await self.expectFailure { _ = try await fixture.install() }+ XCTAssertEqual(try String(contentsOf: marker, encoding: .utf8), "keep")+ try FileManager.default.removeItem(at: fixture.target)+ await self.expectFailure {+ _ = try await ParakeetArchiveDownloader.ensurePresent(descriptor: fixture.descriptor, in: fixture.models, transport: { _, progress in+ try FileManager.default.createDirectory(at: fixture.target, withIntermediateDirectories: false)+ try Data("keep".utf8).write(to: marker)+ return try fixture.transport(progress)+ })+ }+ XCTAssertEqual(try String(contentsOf: marker, encoding: .utf8), "keep")+ try fixture.assertPreservedSiblingsAndNoStage()+ }++ func testBadHTTPResponseAndWrongLengthCleanDownloadedFile() async throws {+ for status in [404, 200] {+ let fixture = try Fixture()+ defer { fixture.cleanup() }+ await self.expectFailure {+ _ = try await ParakeetArchiveDownloader.ensurePresent(descriptor: fixture.descriptor, in: fixture.models, transport: { url, _ in+ let file = fixture.base.appendingPathComponent("returned-download")+ try Data("short response".utf8).write(to: file)+ let response = try XCTUnwrap(HTTPURLResponse(url: url, statusCode: status, httpVersion: nil, headerFields: nil))+ return (file, response)+ })+ }+ XCTAssertFalse(FileManager.default.fileExists(atPath: fixture.base.appendingPathComponent("returned-download").path))+ XCTAssertFalse(FileManager.default.fileExists(atPath: fixture.target.path))+ try fixture.assertPreservedSiblingsAndNoStage()+ }+ }++ func testSymlinkCacheRootAndNestedInstalledLinksAreRejected() async throws {+ let fixture = try Fixture()+ defer { fixture.cleanup() }+ let alias = fixture.base.appendingPathComponent("alias")+ try FileManager.default.createSymbolicLink(at: alias, withDestinationURL: fixture.models)+ await self.expectFailure { _ = try await ParakeetArchiveDownloader.ensurePresent(descriptor: fixture.descriptor, in: alias, transport: { _, _ in+ XCTFail("A symlink cache root must not download")+ throw ProbeFailure.injected+ }) }+ _ = try await fixture.install()+ let link = fixture.target.appendingPathComponent("unexpected-link")+ try FileManager.default.createSymbolicLink(at: link, withDestinationURL: fixture.models.appendingPathComponent("parakeet-tdt-0.6b-v3-coreml"))+ XCTAssertFalse(ParakeetArchiveDownloader.artifactsAreComplete(at: fixture.target, descriptor: fixture.descriptor))+ await self.expectFailure { _ = try await fixture.install() }+ try fixture.assertPreservedSiblingsAndNoStage()+ }++ func testPinnedManifestIsVerifiedBeforeRevisionWriteAndStageValidation() async throws {+ let fixture = try Fixture(includeManifest: true)+ defer { fixture.cleanup() }+ let calls = ProgressRecorder()+ let result = try await ParakeetArchiveDownloader.ensurePresent(+ descriptor: fixture.descriptor,+ in: fixture.models,+ stageValidator: { stage in+ XCTAssertTrue(fixture.descriptor.artifactsAreComplete(at: stage))+ calls.record(.loading)+ },+ transport: { _, progress in try fixture.transport(progress) },+ revisionWriter: { stage, descriptor in+ try ParakeetArchiveInstaller.verify(folder: stage, folderName: descriptor.folderName, manifestSHA256: XCTUnwrap(descriptor.manifestSHA256))+ calls.record(.optimizing)+ try descriptor.writeInstallationRevision(at: stage)+ }+ )+ XCTAssertEqual(result, fixture.target)+ XCTAssertEqual(calls.values.count, 2)+ XCTAssertEqual(fixture.descriptor.installedManifestSHA256(at: result), fixture.descriptor.manifestSHA256)+ try fixture.assertPreservedSiblingsAndNoStage()+ }++ func testCachedArchiveMarkerCannotBypassChangedManifestPin() async throws {+ let fixture = try Fixture(includeManifest: true)+ defer { fixture.cleanup() }+ _ = try await fixture.install()+ var changed = fixture.descriptor+ changed.manifestSHA256 = String(repeating: "0", count: 64)+ XCTAssertFalse(ParakeetArchiveDownloader.artifactsAreComplete(at: fixture.target, descriptor: changed))+ do {+ _ = try await ParakeetArchiveDownloader.ensurePresent(+ descriptor: changed,+ in: fixture.models,+ replaceExisting: true,+ transport: { _, progress in try fixture.transport(progress) }+ )+ XCTFail("A matching archive marker cannot bypass a mismatched manifest pin")+ } catch let error as ParakeetArchiveInstaller.InstallError {+ XCTAssertEqual(error, .manifestMismatch)+ }+ XCTAssertTrue(ParakeetArchiveDownloader.artifactsAreComplete(at: fixture.target, descriptor: fixture.descriptor))+ try fixture.assertPreservedSiblingsAndNoStage()+ }++ func testBadPinnedManifestOrPayloadNeverWritesRevisionOrValidatesAndPreservesOldModel() async throws {+ for tamperPayload in [false, true] {+ let old = try Fixture()+ let newer = try Fixture(+ artifactContents: "new",+ includeManifest: true,+ tamperManifestFile: tamperPayload,+ manifestHashOverride: tamperPayload ? nil : String(repeating: "0", count: 64)+ )+ defer { old.cleanup(); newer.cleanup() }+ _ = try await old.install()+ let calls = ProgressRecorder()+ do {+ _ = try await ParakeetArchiveDownloader.ensurePresent(+ descriptor: newer.descriptor,+ in: old.models,+ replaceExisting: true,+ stageValidator: { _ in calls.record(.loading) },+ transport: { _, progress in try newer.transport(progress) },+ revisionWriter: { _, _ in calls.record(.optimizing) }+ )+ XCTFail("Expected pinned manifest/payload rejection")+ } catch let error as ParakeetArchiveInstaller.InstallError {+ if tamperPayload {+ guard case .fileMismatch = error else { return XCTFail("Expected payload mismatch, got \(error)") }+ } else {+ XCTAssertEqual(error, .manifestMismatch)+ }+ }+ XCTAssertTrue(calls.values.isEmpty)+ XCTAssertTrue(old.descriptor.artifactsAreComplete(at: old.target))+ XCTAssertEqual(try String(contentsOf: old.target.appendingPathComponent("Encoder-1.mlmodelc/weights/weight.bin"), encoding: .utf8), "fixture")+ try old.assertPreservedSiblingsAndNoStage()+ try newer.assertPreservedSiblingsAndNoStage()+ }+ }++ func testLowOrUnknownCapacityRefusesBeforeTransferAndKeepsExistingModel() async throws {+ let old = try Fixture()+ let newer = try Fixture(artifactContents: "new", includeManifest: true)+ defer { old.cleanup(); newer.cleanup() }+ _ = try await old.install()+ let required = newer.descriptor.expectedDownloadBytes * 2 + 32 * 1024 * 1024+ for available in [Int64(0), required - 1, -1] {+ let calls = ProgressRecorder()+ do {+ _ = try await ParakeetArchiveDownloader.ensurePresent(+ descriptor: newer.descriptor,+ in: old.models,+ replaceExisting: true,+ stageValidator: { _ in calls.record(.loading) },+ transport: { _, progress in calls.record(.preparingDownload); return try newer.transport(progress) },+ capacityReader: { directory in+ XCTAssertEqual(directory, old.models)+ XCTAssertFalse(Thread.isMainThread)+ return available+ },+ revisionWriter: { _, _ in calls.record(.optimizing) }+ )+ XCTFail("Expected capacity refusal")+ } catch let error as ParakeetArchiveDownloader.DownloadError {+ if available < 0 {+ guard case .capacityUnavailable = error else { return XCTFail("Expected unknown-capacity error, got \(error)") }+ } else {+ guard case let .insufficientSpace(needed, free) = error else { return XCTFail("Expected low-space error, got \(error)") }+ XCTAssertEqual(needed, required)+ XCTAssertEqual(free, available)+ }+ }+ XCTAssertTrue(calls.values.isEmpty)+ XCTAssertTrue(old.descriptor.artifactsAreComplete(at: old.target))+ XCTAssertEqual(try String(contentsOf: old.target.appendingPathComponent("Encoder-1.mlmodelc/weights/weight.bin"), encoding: .utf8), "fixture")+ try old.assertPreservedSiblingsAndNoStage()+ try newer.assertPreservedSiblingsAndNoStage()+ }+ }++ func testCapacityReaderFailureHasDefinedErrorAndNeverStartsTransfer() async throws {+ let fixture = try Fixture()+ defer { fixture.cleanup() }+ do {+ _ = try await ParakeetArchiveDownloader.ensurePresent(+ descriptor: fixture.descriptor,+ in: fixture.models,+ transport: { _, _ in XCTFail("Capacity must be checked before network"); throw ProbeFailure.injected },+ capacityReader: { _ in throw ProbeFailure.injected }+ )+ XCTFail("Expected unknown-capacity refusal")+ } catch let error as ParakeetArchiveDownloader.DownloadError {+ guard case .capacityUnavailable = error else { return XCTFail("Expected capacity error, got \(error)") }+ }+ XCTAssertFalse(FileManager.default.fileExists(atPath: fixture.target.path))+ try fixture.assertPreservedSiblingsAndNoStage()+ }++ func testExactReservedCapacityAllowsFirstInstallOffMain() async throws {+ let fixture = try Fixture(includeManifest: true)+ defer { fixture.cleanup() }+ let result = try await ParakeetArchiveDownloader.ensurePresent(+ descriptor: fixture.descriptor,+ in: fixture.models,+ transport: { _, progress in try fixture.transport(progress) },+ capacityReader: { _ in+ XCTAssertFalse(Thread.isMainThread)+ return fixture.descriptor.expectedDownloadBytes * 2 + 32 * 1024 * 1024+ }+ )+ XCTAssertTrue(ParakeetArchiveDownloader.artifactsAreComplete(at: result, descriptor: fixture.descriptor))+ try fixture.assertPreservedSiblingsAndNoStage()+ }++ private func expectFailure(_ body: () async throws -> Void) async {+ do { try await body(); XCTFail("Expected archive installation to fail") } catch {}+ }++ private enum ProbeFailure: Error { case injected }++ private actor Started {+ private var started = false+ private var continuation: CheckedContinuation<Void, Never>?+ func signal() { self.started = true; self.continuation?.resume(); self.continuation = nil }+ func wait() async {+ if self.started { return }+ await withCheckedContinuation { self.continuation = $0 }+ }+ }++ private actor UpdateValidationGate {+ private(set) var count = 0+ private var continuations: [CheckedContinuation<Void, Never>] = []+ private var released = false+ func enter() async {+ self.count += 1+ guard !self.released else { return }+ await withCheckedContinuation { self.continuations.append($0) }+ }++ func releaseAll() {+ self.released = true+ let pending = self.continuations+ self.continuations = []+ for continuation in pending {+ continuation.resume()+ }+ }+ }++ private final class ProgressRecorder: @unchecked Sendable {+ private let lock = NSLock()+ private var progress: [ModelPreparationProgress] = []+ var values: [ModelPreparationProgress] { self.lock.withLock { self.progress } }+ func record(_ value: ModelPreparationProgress) { self.lock.withLock { self.progress.append(value) } }+ }++ private struct Entry {+ let path: String+ var data = Data()+ var type: UInt8 = 48+ }++ private struct Fixture: Sendable {+ let base: URL+ let models: URL+ let descriptor: ParakeetSpeechModelCatalog.Descriptor+ let archive: Data+ var target: URL { self.descriptor.cacheDirectory(in: self.models) }++ init(+ checksum: String? = nil,+ omitLastArtifact: Bool = false,+ rootName: String = "fluid-parakeet-mini-coreml",+ extraEntry: Entry? = nil,+ artifactContents: String = "fixture",+ includeManifest: Bool = false,+ tamperManifestFile: Bool = false,+ manifestHashOverride: String? = nil+ ) throws {+ self.base = FileManager.default.temporaryDirectory.appendingPathComponent("ParakeetArchiveDownloaderTests-" + UUID().uuidString, isDirectory: true)+ self.models = self.base.appendingPathComponent("Models", isDirectory: true)+ try FileManager.default.createDirectory(at: self.models, withIntermediateDirectories: true)+ for name in ["parakeet-tdt-0.6b-v2-coreml", "parakeet-tdt-0.6b-v3-coreml", "fluid-parakeet-pico-coreml", "parakeet-eou-streaming"] {+ let sibling = self.models.appendingPathComponent(name, isDirectory: true)+ try FileManager.default.createDirectory(at: sibling, withIntermediateDirectories: false)+ try Data(name.utf8).write(to: sibling.appendingPathComponent("keep"))+ }+ let source = ParakeetSpeechModelCatalog.mini+ var entries = source.requiredModelNames.flatMap { name in+ ["coremldata.bin", "metadata.json", "weights/weight.bin"].map {+ Entry(path: "\(rootName)/\(name)/\($0)", data: Data(artifactContents.utf8))+ }+ }+ if omitLastArtifact { entries.removeLast() }+ entries.append(Entry(path: "\(rootName)/\(source.vocabularyFile)", data: Data("{}".utf8)))+ if let extraEntry { entries.append(extraEntry) }+ var manifestSHA256: String?+ if includeManifest {+ let manifest: [String: Any] = [+ "folderName": rootName,+ "totalSize": entries.reduce(0) { $0 + $1.data.count },+ "files": entries.map { entry in+ [+ "path": String(entry.path.dropFirst(rootName.count + 1)),+ "size": entry.data.count,+ "sha256": SHA256.hash(data: entry.data).map { String(format: "%02x", $0) }.joined(),+ ] as [String: Any]+ },+ ]+ let data = try JSONSerialization.data(withJSONObject: manifest, options: [.sortedKeys])+ manifestSHA256 = manifestHashOverride ?? SHA256.hash(data: data).map { String(format: "%02x", $0) }.joined()+ if tamperManifestFile { entries[0].data = Data("tampered".utf8) }+ entries.append(Entry(path: "\(rootName)/manifest.json", data: data))+ }+ self.archive = Self.tar(entries)+ self.descriptor = .init(+ modelID: source.modelID,+ variant: source.variant,+ folderName: source.folderName,+ expectedDownloadBytes: Int64(self.archive.count),+ archiveURL: source.archiveURL,+ archiveSHA256: checksum ?? SHA256.hash(data: self.archive).map { String(format: "%02x", $0) }.joined(),+ requiredModelNames: source.requiredModelNames,+ vocabularyFile: source.vocabularyFile,+ displayName: source.displayName,+ humanReadableName: source.humanReadableName,+ languageSupport: source.languageSupport,+ supportedLanguageCodes: source.supportedLanguageCodes,+ downloadSize: source.downloadSize,+ cardDescription: source.cardDescription,+ performanceRatings: source.performanceRatings,+ manifestSHA256: manifestSHA256+ )+ }++ func install(progress: @escaping @Sendable (ModelPreparationProgress) -> Void = { _ in }) async throws -> URL {+ try await ParakeetArchiveDownloader.ensurePresent(descriptor: self.descriptor, in: self.models, progressHandler: progress, transport: { _, progress in+ try self.transport(progress)+ })+ }++ func transport(_ progress: @Sendable (Int64, Int64) -> Void) throws -> (URL, URLResponse) {+ let file = self.base.appendingPathComponent("download-" + UUID().uuidString)+ try self.archive.write(to: file)+ progress(Int64(self.archive.count / 2), -1)+ progress(Int64(self.archive.count), Int64(self.archive.count))+ let url = try XCTUnwrap(self.descriptor.archiveURL)+ return try (file, XCTUnwrap(HTTPURLResponse(url: url, statusCode: 200, httpVersion: nil, headerFields: nil)))+ }++ func assertPreservedSiblingsAndNoStage(file: StaticString = #filePath, line: UInt = #line) throws {+ for name in ["parakeet-tdt-0.6b-v2-coreml", "parakeet-tdt-0.6b-v3-coreml", "fluid-parakeet-pico-coreml", "parakeet-eou-streaming"] {+ XCTAssertEqual(try String(contentsOf: self.models.appendingPathComponent("\(name)/keep"), encoding: .utf8), name, file: file, line: line)+ }+ XCTAssertEqual(try FileManager.default.contentsOfDirectory(atPath: self.models.path).filter { $0.hasSuffix(".staging") }, [], file: file, line: line)+ XCTAssertEqual(try FileManager.default.contentsOfDirectory(atPath: self.base.path).filter { $0.hasPrefix("download-") }, [], file: file, line: line)+ }++ func cleanup() { try? FileManager.default.removeItem(at: self.base) }++ private static func tar(_ entries: [Entry]) -> Data {+ var archive = Data()+ for entry in entries {+ var header = [UInt8](repeating: 0, count: 512)+ for (offset, byte) in entry.path.utf8.prefix(100).enumerated() {+ header[offset] = byte+ }+ let size = String(format: "%011o", entry.data.count)+ for (offset, byte) in size.utf8.enumerated() {+ header[124 + offset] = byte+ }+ for offset in 148..<156 {+ header[offset] = 32+ }+ header[156] = entry.type+ let checksum = String(format: "%06o", header.reduce(0) { $0 + Int($1) })+ for (offset, byte) in checksum.utf8.enumerated() {+ header[148 + offset] = byte+ }+ header[154] = 0; header[155] = 32+ archive.append(contentsOf: header)+ archive.append(entry.data)+ archive.append(Data(repeating: 0, count: (512 - entry.data.count % 512) % 512))+ }+ archive.append(Data(repeating: 0, count: 1024))+ return archive+ }+ }+}diff --git a/Tests/FluidDictationIntegrationTests/ParakeetArchiveInstallerTests.swift b/Tests/FluidDictationIntegrationTests/ParakeetArchiveInstallerTests.swiftnew file mode 100644index 00000000..72c8a698--- /dev/null+++ b/Tests/FluidDictationIntegrationTests/ParakeetArchiveInstallerTests.swift@@ -0,0 +1,193 @@+@testable import FluidVoice_Debug+import Foundation+import XCTest++/// Byte-identical publisher/iPhone archives; Mac must return the same verdict for every case.+final nonisolated class ParakeetArchiveInstallerTests: XCTestCase {+ private struct TarCase: Decodable {+ let file: String+ let folderName: String+ let manifestSHA256: String+ let verdict: String+ }++ private var fixtures: URL {+ URL(fileURLWithPath: #filePath).deletingLastPathComponent()+ .appendingPathComponent("Fixtures/ModelRelease/tars", isDirectory: true)+ }++ private func cases() throws -> [TarCase] {+ try JSONDecoder().decode([TarCase].self, from: Data(contentsOf: self.fixtures.appendingPathComponent("expected.json")))+ }++ private func scratch() throws -> URL {+ let url = FileManager.default.temporaryDirectory.appendingPathComponent("ArchiveInstallerTests-\(UUID().uuidString)", isDirectory: true)+ try FileManager.default.createDirectory(at: url, withIntermediateDirectories: false)+ return url+ }++ private func unpack(_ tar: TarCase, staging: URL) throws -> URL {+ try ParakeetArchiveInstaller.unpack(+ archive: self.fixtures.appendingPathComponent(tar.file),+ folderName: tar.folderName,+ staging: staging,+ manifestSHA256: tar.manifestSHA256+ )+ }++ private func verdict(_ error: Error) -> String {+ String(String(describing: error).prefix { $0 != "(" })+ }++ func testEveryCanonicalTarGetsThePublisherAndIPhoneVerdict() throws {+ let base = try scratch()+ defer { try? FileManager.default.removeItem(at: base) }+ let entries = try cases()+ XCTAssertEqual(entries.count, 17)+ for entry in entries {+ let result: String+ do {+ _ = try self.unpack(entry, staging: base.appendingPathComponent(entry.file, isDirectory: true))+ result = "ok"+ } catch { result = self.verdict(error) }+ XCTAssertEqual(result, entry.verdict, entry.file)+ }+ }++ func testVarAndPrivateVarAliasesVerifySameArchiveWithoutChangingFilesOrLinkRules() throws {+ let base = try self.scratch()+ defer { try? FileManager.default.removeItem(at: base) }+ let publicPath = base.path.hasPrefix("/private/var/") ? String(base.path.dropFirst("/private".count)) : base.path+ guard publicPath.hasPrefix("/var/") else { return XCTFail("Expected macOS temporary folder under /var, got \(base.path)") }+ // Build both spellings literally; URL standardization can collapse /private/var.+ let varBase = URL(fileURLWithPath: publicPath, isDirectory: true)+ let privateBase = URL(fileURLWithPath: "/private" + publicPath, isDirectory: true)+ XCTAssertTrue(FileManager.default.fileExists(atPath: varBase.path))+ XCTAssertTrue(FileManager.default.fileExists(atPath: privateBase.path))+ let good = try XCTUnwrap(self.cases().first { $0.file == "good.tar" })+ let sibling = privateBase.appendingPathComponent("other-model", isDirectory: true)+ try FileManager.default.createDirectory(at: sibling, withIntermediateDirectories: false)+ let siblingWeights = sibling.appendingPathComponent("weights")+ try Data("keep".utf8).write(to: siblingWeights)+ let privateFolder = try self.unpack(good, staging: privateBase.appendingPathComponent("staging", isDirectory: true))+ let varFolder = varBase.appendingPathComponent("staging/\(good.folderName)", isDirectory: true)+ let manifest = privateFolder.appendingPathComponent("manifest.json")+ let originalManifest = try Data(contentsOf: manifest)+ let originalNames = try FileManager.default.subpathsOfDirectory(atPath: privateFolder.path).sorted()+ let originalFileIdentity = try XCTUnwrap(try FileManager.default.attributesOfItem(atPath: privateFolder.path)[.systemFileNumber] as? NSNumber)+ for alias in [varFolder, privateFolder] {+ XCTAssertNoThrow(try ParakeetArchiveInstaller.verify(folder: alias, folderName: good.folderName, manifestSHA256: good.manifestSHA256))+ XCTAssertEqual(try ParakeetArchiveInstaller.sha256(of: alias.appendingPathComponent("manifest.json")), good.manifestSHA256)+ XCTAssertEqual(try FileManager.default.attributesOfItem(atPath: alias.path)[.systemFileNumber] as? NSNumber, originalFileIdentity)+ XCTAssertEqual(try Data(contentsOf: alias.appendingPathComponent("manifest.json")), originalManifest)+ XCTAssertEqual(try FileManager.default.subpathsOfDirectory(atPath: alias.path).sorted(), originalNames)+ XCTAssertEqual(try Data(contentsOf: siblingWeights), Data("keep".utf8))+ }+ // Canonicalizing an ancestor alias must never permit a symlink as the model root.+ let rootLink = privateBase.appendingPathComponent("linked-model")+ try FileManager.default.createSymbolicLink(at: rootLink, withDestinationURL: privateFolder)+ XCTAssertThrowsError(try ParakeetArchiveInstaller.verify(folder: rootLink, folderName: good.folderName, manifestSHA256: good.manifestSHA256)) {+ XCTAssertEqual($0 as? ParakeetArchiveInstaller.InstallError, .manifestMismatch)+ }+ try FileManager.default.createSymbolicLink(at: privateFolder.appendingPathComponent("linked-weights"), withDestinationURL: siblingWeights)+ for alias in [varFolder, privateFolder] {+ XCTAssertThrowsError(try ParakeetArchiveInstaller.verify(folder: alias, folderName: good.folderName, manifestSHA256: good.manifestSHA256)) {+ XCTAssertEqual($0 as? ParakeetArchiveInstaller.InstallError, .fileMismatch("linked-weights"))+ }+ XCTAssertEqual(try Data(contentsOf: alias.appendingPathComponent("manifest.json")), originalManifest)+ XCTAssertEqual(try Data(contentsOf: siblingWeights), Data("keep".utf8))+ }+ }++ func testEveryRejectedTarLeavesExistingWeightsAndSiblingUntouched() throws {+ let base = try scratch()+ defer { try? FileManager.default.removeItem(at: base) }+ let installed = base.appendingPathComponent("installed", isDirectory: true)+ let sibling = base.appendingPathComponent("other-model", isDirectory: true)+ for folder in [installed, sibling] {+ try FileManager.default.createDirectory(at: folder, withIntermediateDirectories: false)+ try Data("keep".utf8).write(to: folder.appendingPathComponent("weights"))+ }+ for entry in try self.cases() where entry.verdict != "ok" {+ XCTAssertThrowsError(try unpack(entry, staging: base.appendingPathComponent(entry.file)))+ for folder in [installed, sibling] {+ XCTAssertEqual(try Data(contentsOf: folder.appendingPathComponent("weights")), Data("keep".utf8), entry.file)+ }+ }+ }++ func testPreexistingStagingDirectoryAndSymlinkAreNeverRemoved() throws {+ let base = try scratch()+ defer { try? FileManager.default.removeItem(at: base) }+ let good = try XCTUnwrap(cases().first { $0.file == "good.tar" })+ let protected = base.appendingPathComponent("protected", isDirectory: true)+ try FileManager.default.createDirectory(at: protected, withIntermediateDirectories: false)+ try Data("keep".utf8).write(to: protected.appendingPathComponent("weights"))+ let link = base.appendingPathComponent("linked-staging")+ try FileManager.default.createSymbolicLink(at: link, withDestinationURL: protected)+ for staging in [protected, link] {+ XCTAssertThrowsError(try self.unpack(good, staging: staging)) {+ XCTAssertEqual($0 as? ParakeetArchiveInstaller.InstallError, .invalidStaging)+ }+ XCTAssertEqual(try Data(contentsOf: protected.appendingPathComponent("weights")), Data("keep".utf8))+ XCTAssertNotNil(try? FileManager.default.attributesOfItem(atPath: staging.path))+ }+ }++ func testStandaloneVerificationRejectsLinksWithoutReadingTheirPayload() throws {+ let base = try scratch()+ defer { try? FileManager.default.removeItem(at: base) }+ let good = try XCTUnwrap(cases().first { $0.file == "good.tar" })+ let folder = try unpack(good, staging: base.appendingPathComponent("staging"))+ let external = base.appendingPathComponent("external")+ try Data("keep".utf8).write(to: external)+ try FileManager.default.createSymbolicLink(at: folder.appendingPathComponent("linked"), withDestinationURL: external)+ XCTAssertThrowsError(try ParakeetArchiveInstaller.verify(folder: folder, folderName: good.folderName, manifestSHA256: good.manifestSHA256)) {+ XCTAssertEqual($0 as? ParakeetArchiveInstaller.InstallError, .fileMismatch("linked"))+ }+ XCTAssertEqual(try Data(contentsOf: external), Data("keep".utf8))+ }++ func testInvalidManifestSizesExitWithoutIntegerOverflow() throws {+ let base = try scratch()+ defer { try? FileManager.default.removeItem(at: base) }+ for size in [-1, Int64.max] as [Int64] {+ let folder = base.appendingPathComponent(UUID().uuidString, isDirectory: true)+ try FileManager.default.createDirectory(at: folder, withIntermediateDirectories: false)+ let manifest: [String: Any] = [+ "folderName": "tiny-model", "totalSize": 0,+ "files": [["path": "payload", "size": size, "sha256": String(repeating: "0", count: 64)]],+ ]+ let data = try JSONSerialization.data(withJSONObject: manifest)+ let url = folder.appendingPathComponent("manifest.json")+ try data.write(to: url)+ XCTAssertThrowsError(try ParakeetArchiveInstaller.verify(folder: folder, folderName: "tiny-model", manifestSHA256: ParakeetArchiveInstaller.sha256(of: url))) {+ XCTAssertEqual($0 as? ParakeetArchiveInstaller.InstallError, .manifestMismatch)+ }+ }+ }++ func testOversizedManifestIsRejectedBeforeDecode() throws {+ let base = try scratch()+ defer { try? FileManager.default.removeItem(at: base) }+ let manifest = base.appendingPathComponent("manifest.json")+ try Data(repeating: 32, count: 1_048_577).write(to: manifest)+ XCTAssertThrowsError(try ParakeetArchiveInstaller.verify(folder: base, folderName: "tiny-model", manifestSHA256: ParakeetArchiveInstaller.sha256(of: manifest))) {+ XCTAssertEqual($0 as? ParakeetArchiveInstaller.InstallError, .manifestMismatch)+ }+ }++ func testCancelledUnpackDoesNotCreateStaging() async throws {+ let base = try scratch()+ defer { try? FileManager.default.removeItem(at: base) }+ let good = try XCTUnwrap(cases().first { $0.file == "good.tar" })+ let archive = self.fixtures.appendingPathComponent(good.file)+ let stage = base.appendingPathComponent("staging")+ let task = Task.detached {+ withUnsafeCurrentTask { $0?.cancel() }+ return try ParakeetArchiveInstaller.unpack(archive: archive, folderName: good.folderName, staging: stage, manifestSHA256: good.manifestSHA256)+ }+ do { _ = try await task.value; XCTFail("Expected cancellation") } catch is CancellationError {}+ XCTAssertFalse(FileManager.default.fileExists(atPath: stage.path))+ }+}diff --git a/Tests/FluidDictationIntegrationTests/ParakeetCompactModelDemoTests.swift b/Tests/FluidDictationIntegrationTests/ParakeetCompactModelDemoTests.swiftnew file mode 100644index 00000000..646800b3--- /dev/null+++ b/Tests/FluidDictationIntegrationTests/ParakeetCompactModelDemoTests.swift@@ -0,0 +1,260 @@+import AppKit+import AVFoundation+@testable import FluidVoice_Debug+import Foundation+import SwiftUI+import XCTest++@MainActor+final class ParakeetCompactModelDemoTests: XCTestCase {+ func testOptInNativeOnboardingAndSettingsReview() async throws {+ guard ProcessInfo.processInfo.environment["FLUIDVOICE_COMPACT_MODEL_DEMO"] == "1",+ let audioPath = ProcessInfo.processInfo.environment["FLUIDVOICE_COMPACT_MODEL_AUDIO"]+ else { throw XCTSkip("Explicitly enable the native model review with an English test WAV") }+ let settings = SettingsStore.shared+ settings.onboardingSelectedLanguageID = "en"+ let finished = expectation(description: "Native review closed")+ let window = NSWindow(contentRect: NSRect(x: 0, y: 0, width: 1100, height: 780), styleMask: [.titled, .resizable], backing: .buffered, defer: false)+ window.isReleasedWhenClosed = false+ window.title = "Mini and Pico — Model Review"+ let viewModel = VoiceEngineSettingsViewModel(settings: settings, appServices: .shared)+ viewModel.providerFilter = .nvidia+ viewModel.englishOnlyFilter = true+ let view = CompactModelReviewView(viewModel: viewModel, audioPath: audioPath) {+ window.orderOut(nil)+ finished.fulfill()+ }+ window.contentView = NSHostingView(rootView: view.appTheme(.dark))+ window.center()+ window.makeKeyAndOrderFront(nil)+ NSApp.activate(ignoringOtherApps: true)+ print("COMPACT_MODEL_DEMO_READY window=\(window.windowNumber)")+ await fulfillment(of: [finished], timeout: 600)+ window.contentView = nil+ window.close()+ await AppServices.shared.asr.finishAudioRouteRecoveryTest()+ }+}++@MainActor+private struct CompactModelReviewView: View {+ @ObservedObject var viewModel: VoiceEngineSettingsViewModel+ let audioPath: String+ let onClose: () -> Void+ @State private var page = 0+ @State private var onboardingStep = 2+ @State private var shortcutTarget: ShortcutRecordingTarget?+ @State private var shortcutMessage: String?+ @State private var transcript = "Choose a downloaded model to transcribe the test recording."+ @State private var isTranscribing = false+ private let menuBarManager = MenuBarManager()++ var body: some View {+ VStack(spacing: 0) {+ HStack {+ Picker("Review", selection: self.$page) {+ Text("Voice Engine").tag(0)+ Text("Onboarding").tag(1)+ Text("Test transcription").tag(2)+ }+ .pickerStyle(.segmented)+ .frame(width: 450)+ Spacer()+ Button("Close review", action: self.onClose)+ .disabled(self.isTranscribing || self.viewModel.areSpeechModelActionsBlocked)+ }+ .padding(16)+ Divider()+ switch self.page {+ case 1:+ OnboardingFlowView(+ currentStep: self.$onboardingStep,+ accessibilityEnabled: true,+ accessibilitySetupInProgress: false,+ markAISkipped: {},+ finishOnboarding: {},+ finishOnboardingAtGettingStarted: {},+ openAccessibilitySettings: {},+ restartApp: {},+ menuBarManager: self.menuBarManager,+ activeShortcutRecordingTarget: self.$shortcutTarget,+ shortcutRecordingMessage: self.$shortcutMessage,+ theme: .dark+ )+ .environmentObject(AppServices.shared)+ case 2:+ VStack(alignment: .leading, spacing: 20) {+ Text("English test recording · Microphone stays off")+ HStack {+ Button("Test Mini") { self.transcribe(.fluidParakeetMini) }+ Button("Test Pico") { self.transcribe(.fluidParakeetPico) }+ }+ .disabled(self.isTranscribing)+ if self.isTranscribing { ProgressView("Loading and transcribing…") }+ Text(self.transcript).textSelection(.enabled)+ Spacer()+ }+ .padding(32)+ .frame(maxWidth: .infinity, maxHeight: .infinity, alignment: .topLeading)+ default:+ ScrollView {+ VoiceEngineSettingsView(viewModel: self.viewModel, settings: .shared, theme: .dark)+ .padding(20)+ }+ }+ }+ .preferredColorScheme(.dark)+ .background(Color(nsColor: .windowBackgroundColor))+ }++ private func transcribe(_ model: SettingsStore.SpeechModel) {+ self.isTranscribing = true+ self.transcript = ""+ Task { @MainActor in+ defer { self.isTranscribing = false }+ do {+ let samples = try await Self.readAudio(self.audioPath)+ let provider = FluidAudioProvider(+ modelOverride: model,+ configureWordBoosting: false,+ enhancementOptions: .init(experimentalUnifiedFinalEnabled: false, pronunciationMatchingEnabled: false, customDictionaryEntries: [])+ )+ try await provider.prepare()+ let result = try await provider.transcribe(samples)+ self.transcript = "\(model.humanReadableName): \(result.text)"+ } catch {+ self.transcript = error.localizedDescription+ }+ }+ }++ @concurrent private static func readAudio(_ path: String) async throws -> [Float] {+ let file = try AVAudioFile(forReading: URL(fileURLWithPath: path), commonFormat: .pcmFormatFloat32, interleaved: false)+ guard file.processingFormat.sampleRate == 16_000, file.processingFormat.channelCount == 1,+ let buffer = AVAudioPCMBuffer(pcmFormat: file.processingFormat, frameCapacity: AVAudioFrameCount(file.length))+ else { throw CocoaError(.fileReadCorruptFile) }+ try file.read(into: buffer)+ guard let channel = buffer.floatChannelData?[0] else { throw CocoaError(.fileReadCorruptFile) }+ return Array(UnsafeBufferPointer(start: channel, count: Int(buffer.frameLength)))+ }+}++@MainActor+final class WindowSizingRegressionTests: XCTestCase {+ func testRepeatedLayoutAndResizeEventsDoNotRewriteStableBounds() async {+ let window = SizingRecordingWindow()+ let view = FluidWindowSizingNSView(sizing: .minimum(width: 800, height: 500))+ window.contentView = view+ await self.drainSizing()+ window.resetWrites()+ for _ in 0..<100 {+ view.sizing = .minimum(width: 800, height: 500)+ NotificationCenter.default.post(name: NSWindow.didResizeNotification, object: window)+ }+ XCTAssertEqual(window.boundsWrites, 0, "A SwiftUI update must not synchronously invalidate window constraints")+ await self.drainSizing()+ XCTAssertEqual(window.boundsWrites, 0, "Stable bounds must stay untouched after the coalesced update")+ XCTAssertEqual(window.frameWrites, 0)+ window.contentView = nil+ }++ func testRapidSizingChangesApplyOnlyTheLatestBoundsAfterLayout() async {+ let window = SizingRecordingWindow()+ let view = FluidWindowSizingNSView(sizing: .minimum(width: 800, height: 500))+ window.contentView = view+ await self.drainSizing()+ window.resetWrites()+ view.sizing = .minimum(width: 900, height: 550)+ view.sizing = .minimum(width: 940, height: 700)+ XCTAssertEqual(window.boundsWrites, 0)+ await self.drainSizing()+ XCTAssertEqual(window.minSize, NSSize(width: 940, height: 700))+ XCTAssertEqual(window.minimumWrites, 1)+ window.contentView = nil+ }++ func testFullScreenLayoutDoesNotChangeAnyWindowBoundsOrFrame() async {+ let window = SizingRecordingWindow()+ let view = FluidWindowSizingNSView(sizing: .minimum(width: 800, height: 500))+ window.contentView = view+ await self.drainSizing()+ window.isFullScreenForTest = true+ window.resetWrites()+ view.sizing = .minimum(width: 940, height: 700)+ NotificationCenter.default.post(name: NSWindow.didResizeNotification, object: window)+ await self.drainSizing()+ XCTAssertEqual(window.boundsWrites, 0, "Full-screen sizing belongs entirely to macOS")+ XCTAssertEqual(window.frameWrites, 0)+ window.isFullScreenForTest = false+ // Exit must restore the pending bounds even without a final resize event.+ NotificationCenter.default.post(name: NSWindow.didExitFullScreenNotification, object: window)+ await self.drainSizing()+ XCTAssertEqual(window.minSize, NSSize(width: 940, height: 700))+ window.contentView = nil+ }++ func testQueuedSizingDoesNotWriteToThePreviousWindow() async {+ let oldWindow = SizingRecordingWindow()+ let newWindow = SizingRecordingWindow()+ let view = FluidWindowSizingNSView(sizing: .minimum(width: 800, height: 500))+ oldWindow.contentView = view+ await self.drainSizing()+ oldWindow.resetWrites()+ view.sizing = .minimum(width: 940, height: 700)+ oldWindow.contentView = nil+ newWindow.contentView = view+ await self.drainSizing()+ XCTAssertEqual(oldWindow.boundsWrites, 0)+ XCTAssertEqual(oldWindow.frameWrites, 0)+ XCTAssertEqual(newWindow.minSize, NSSize(width: 940, height: 700))+ newWindow.contentView = nil+ }++ private func drainSizing() async {+ for _ in 0..<3 {+ await withCheckedContinuation { continuation in+ DispatchQueue.main.async { continuation.resume() }+ }+ }+ }+}++@MainActor+private final class SizingRecordingWindow: NSWindow {+ var minimumWrites = 0+ var maximumWrites = 0+ var frameWrites = 0+ var isFullScreenForTest = false+ var boundsWrites: Int { self.minimumWrites + self.maximumWrites }++ init() {+ super.init(contentRect: NSRect(x: 0, y: 0, width: 1000, height: 700), styleMask: [.titled, .resizable], backing: .buffered, defer: false)+ self.isReleasedWhenClosed = false+ }++ override var minSize: NSSize {+ get { super.minSize }+ set { self.minimumWrites += 1; super.minSize = newValue }+ }++ override var maxSize: NSSize {+ get { super.maxSize }+ set { self.maximumWrites += 1; super.maxSize = newValue }+ }++ override var styleMask: NSWindow.StyleMask {+ get { self.isFullScreenForTest ? super.styleMask.union(.fullScreen) : super.styleMask }+ set { super.styleMask = newValue }+ }++ override func setFrame(_ frameRect: NSRect, display flag: Bool, animate animateFlag: Bool) {+ self.frameWrites += 1+ super.setFrame(frameRect, display: flag, animate: animateFlag)+ }++ func resetWrites() {+ self.minimumWrites = 0+ self.maximumWrites = 0+ self.frameWrites = 0+ }+}diff --git a/Tests/FluidDictationIntegrationTests/ParakeetCompactModelSmokeTests.swift b/Tests/FluidDictationIntegrationTests/ParakeetCompactModelSmokeTests.swiftnew file mode 100644index 00000000..9ec81092--- /dev/null+++ b/Tests/FluidDictationIntegrationTests/ParakeetCompactModelSmokeTests.swift@@ -0,0 +1,222 @@+import AVFoundation+import CryptoKit+@testable import FluidVoice_Debug+import Foundation+import XCTest+#if arch(arm64)+import FluidAudio+#endif++@MainActor+final class ParakeetCompactModelSmokeTests: XCTestCase {+ func testShippedRuntimeCheckRecordingIsBundledAndUnchanged() throws {+ let url = try XCTUnwrap(CompactSpeechModelRuntimeCheck.recordingURL)+ let data = try Data(contentsOf: url)+ XCTAssertEqual(data.count, 131_162)+ XCTAssertEqual(+ SHA256.hash(data: data).map { String(format: "%02x", $0) }.joined(),+ "961ac4a204b913fb953e1ef9a7d4a54a235f69a3bf0a818a6712968bacdde68d"+ )+ let samples = try CompactSpeechModelRuntimeCheck.samples()+ XCTAssertEqual(samples.count, 65_581)+ XCTAssertTrue(samples.allSatisfy(\.isFinite))+ XCTAssertTrue(samples.contains { abs($0) > 0.01 })+ }++ func testRuntimeCheckRequiresFiveDistinctWholeWords() {+ XCTAssertTrue(CompactSpeechModelRuntimeCheck.accepts("QUICK, brown fox jumps over."))+ XCTAssertTrue(CompactSpeechModelRuntimeCheck.accepts("The quick brown fox jumps over the lazy dog near quiet water."))+ XCTAssertFalse(CompactSpeechModelRuntimeCheck.accepts("quick brown fox jumps"))+ XCTAssertFalse(CompactSpeechModelRuntimeCheck.accepts("quick quick quick quick quick"))+ XCTAssertFalse(CompactSpeechModelRuntimeCheck.accepts("quickly brownish foxes jumping overhead"))+ XCTAssertFalse(CompactSpeechModelRuntimeCheck.accepts(""))+ }++ func testRuntimeCheckRejectsInvalidAndOversizedPCM() throws {+ for data in [Data(), Data([0]), Data(repeating: 0, count: 32_001), Data(repeating: 0, count: 480_002)] {+ XCTAssertThrowsError(try CompactSpeechModelRuntimeCheck.decode(data)) { error in+ XCTAssertEqual(error as? CompactSpeechModelRuntimeCheck.Failure, .invalidRecording)+ }+ }+ var data = Data(repeating: 0, count: 32_000)+ data[0] = 0xff+ data[1] = 0x7f+ data[2] = 0+ data[3] = 0x80+ let samples = try CompactSpeechModelRuntimeCheck.decode(data)+ XCTAssertEqual(samples.count, 16_000)+ XCTAssertEqual(samples[0], 32_767.0 / 32_768)+ XCTAssertEqual(samples[1], -1)+ }++ func testRuntimeDeadlineJoinsCanceledProofCleanup() async throws {+ let activity = RuntimeCheckActivity()+ do {+ try await CompactSpeechModelRuntimeCheck.withDeadline(.milliseconds(10)) {+ do {+ try await Task.sleep(for: .seconds(60))+ } catch {+ await activity.finish()+ throw error+ }+ }+ XCTFail("A blocked proof must time out")+ } catch {+ XCTAssertEqual(error as? CompactSpeechModelRuntimeCheck.Failure, .timedOut)+ }+ let finished = await activity.finished+ XCTAssertTrue(finished, "The installer must not delete staged files while proof still uses them")+ }++ func testCanceledRuntimeProofJoinsCleanupWithoutReportingBadWeights() async throws {+ let activity = RuntimeCheckActivity()+ let (started, continuation) = AsyncStream<Void>.makeStream()+ let task = Task {+ try await CompactSpeechModelRuntimeCheck.withDeadline(.seconds(60)) {+ continuation.yield(())+ continuation.finish()+ do {+ try await Task.sleep(for: .seconds(60))+ } catch {+ await activity.finish()+ throw error+ }+ }+ }+ for await _ in started { break }+ task.cancel()+ do {+ try await task.value+ XCTFail("Canceled verification must not publish weights")+ } catch {+ XCTAssertTrue(error is CancellationError)+ }+ let finished = await activity.finished+ XCTAssertTrue(finished)+ }++ func testSuccessfulRuntimeProofCancelsDeadline() async throws {+ let activity = RuntimeCheckActivity()+ try await CompactSpeechModelRuntimeCheck.withDeadline(.seconds(60)) {+ await activity.finish()+ }+ let finished = await activity.finished+ XCTAssertTrue(finished)+ }++ func testHostedOldWeightsStayUsableUntilExplicitValidatedUpdate() async throws {+ #if arch(arm64)+ guard ProcessInfo.processInfo.environment["FLUIDVOICE_COMPACT_MODEL_AUDIO"] != nil else {+ throw XCTSkip("Explicitly enable hosted compact model runtime checks")+ }+ let root = FileManager.default.temporaryDirectory.appendingPathComponent("FluidVoiceCompactUpdate-\(UUID().uuidString)", isDirectory: true)+ defer { try? FileManager.default.removeItem(at: root) }+ let selection = SettingsStore.shared.selectedSpeechModel+ let fixtures: [(SettingsStore.SpeechModel, Int64, String)] = [+ (.fluidParakeetMini, 254_126_592, "12109f89c80b959847ac80ae963714a00af08f029144c3e4a2a8c1641f528a36"),+ (.fluidParakeetPico, 161_201_152, "afcdd76d4aba0328c97c858ee5c4c227ab5e23cc6885de5299d009c3671fe5d6"),+ ]+ for (model, bytes, oldHash) in fixtures {+ let latest = try XCTUnwrap(model.parakeetDescriptor)+ let oldURL = try XCTUnwrap(URL(string: "https://models.fluidvoice.app/parakeet/fluid-\(latest.variant.rawValue)/1.0.0/\(latest.folderName).tar"))+ let old = latest.replacingArchive(url: oldURL, sha256: oldHash, byteCount: bytes)+ let directory = try await ParakeetArchiveDownloader.ensurePresent(descriptor: old, in: root)+ let probe = SpeechModelInstallationSnapshot.Probe(modelID: model.id, kind: .parakeet(latest))+ let before = try await SpeechModelInstallationSnapshot.scanResult([probe], modelsDirectory: root)+ XCTAssertEqual(before.installedIDs, [model.id])+ XCTAssertEqual(before.updateAvailableIDs, [model.id])+ XCTAssertEqual(before.installedArchiveHashes[model.id], oldHash)+ do {+ let provider = FluidAudioProvider(modelOverride: model, configureWordBoosting: false)+ provider.modelCacheRootForTesting = root+ try await provider.prepare()+ XCTAssertTrue(provider.isReady)+ XCTAssertEqual(provider.pronunciationModelKeyForTesting, old.pronunciationModelKey)+ XCTAssertEqual(latest.installedArchiveSHA256(at: directory), oldHash)+ }+ let updater = FluidAudioProvider(modelOverride: model, configureWordBoosting: false, updateCompactWeights: true)+ updater.modelCacheRootForTesting = root+ try await updater.prepare()+ XCTAssertTrue(latest.artifactsAreComplete(at: directory))+ let after = try await SpeechModelInstallationSnapshot.scanResult([probe], modelsDirectory: root)+ XCTAssertEqual(after.installedIDs, [model.id])+ XCTAssertTrue(after.updateAvailableIDs.isEmpty)+ XCTAssertEqual(after.installedArchiveHashes[model.id], latest.archiveSHA256)+ let provider = FluidAudioProvider(modelOverride: model, configureWordBoosting: false)+ provider.modelCacheRootForTesting = root+ try await provider.prepare()+ XCTAssertTrue(provider.isReady)+ XCTAssertEqual(provider.pronunciationModelKeyForTesting, latest.pronunciationModelKey)+ XCTAssertEqual(SettingsStore.shared.selectedSpeechModel, selection)+ }+ #else+ throw XCTSkip("Compact Parakeet models require Apple silicon")+ #endif+ }++ func testHostedCompactModelsDownloadLoadTranscribeAndExtractDictionaryFrames() async throws {+ #if arch(arm64)+ guard let audioPath = ProcessInfo.processInfo.environment["FLUIDVOICE_COMPACT_MODEL_AUDIO"] else {+ throw XCTSkip("Set FLUIDVOICE_COMPACT_MODEL_AUDIO to an English test recording for the hosted model check")+ }+ let verificationSamples = try CompactSpeechModelRuntimeCheck.samples()+ let file = try AVAudioFile(forReading: URL(fileURLWithPath: audioPath), commonFormat: .pcmFormatFloat32, interleaved: false)+ XCTAssertEqual(file.processingFormat.sampleRate, 16_000)+ XCTAssertEqual(file.processingFormat.channelCount, 1)+ let buffer = try XCTUnwrap(AVAudioPCMBuffer(pcmFormat: file.processingFormat, frameCapacity: AVAudioFrameCount(file.length)))+ try file.read(into: buffer)+ let channel = try XCTUnwrap(buffer.floatChannelData?[0])+ let samples = Array(UnsafeBufferPointer(start: channel, count: Int(buffer.frameLength)))+ XCTAssertFalse(samples.isEmpty)+ XCTAssertLessThanOrEqual(samples.count, 240_000)+ let root = FileManager.default.temporaryDirectory.appendingPathComponent("FluidVoiceCompactModels-\(UUID().uuidString)", isDirectory: true)+ defer { try? FileManager.default.removeItem(at: root) }+ let selection = SettingsStore.shared.selectedSpeechModel+ for descriptor in [ParakeetSpeechModelCatalog.mini, ParakeetSpeechModelCatalog.pico] {+ // Exercise first-download publication through the real provider's staged proof.+ do {+ let model: SettingsStore.SpeechModel = descriptor.variant == .mini ? .fluidParakeetMini : .fluidParakeetPico+ let provider = FluidAudioProvider(modelOverride: model, configureWordBoosting: false)+ provider.modelCacheRootForTesting = root+ try await provider.prepare()+ XCTAssertTrue(provider.isReady)+ XCTAssertFalse(provider.isWordBoostingActive)+ }+ let directory = descriptor.cacheDirectory(in: root)+ XCTAssertTrue(descriptor.artifactsAreComplete(at: directory))+ let models = try await AsrModels.loadLocalOnly(from: directory, version: descriptor.asrModelVersion)+ XCTAssertEqual(models.version, descriptor.asrModelVersion)+ XCTAssertNotNil(models.splitEncoder)+ XCTAssertEqual(models.encoderOutputShape.count, 3)+ let hiddenDimension = try XCTUnwrap(models.encoderOutputShape.dropFirst().first)+ XCTAssertEqual(hiddenDimension, models.version.encoderHiddenSize)+ let manager = AsrManager(config: .default)+ do {+ try await manager.initialize(models: models)+ let verification = try await manager.transcribe(verificationSamples, source: .microphone)+ XCTAssertTrue(CompactSpeechModelRuntimeCheck.accepts(verification.text), "Shipped sentence failed: \(verification.text)")+ let result = try await manager.transcribe(samples, source: .microphone)+ XCTAssertGreaterThanOrEqual(result.text.split(separator: " ").count, 3)+ let embedding = try await manager.pronunciationEmbedding(audioSamples: samples, focalSampleRange: 0..<samples.count)+ XCTAssertEqual(embedding.values.count, models.version.encoderHiddenSize)+ XCTAssertTrue(embedding.values.allSatisfy(\.isFinite))+ let frames = try await DictionaryTemporalEncoder.encode(samples, models: models)+ XCTAssertTrue(frames.isValid)+ XCTAssertEqual(frames.hiddenSize, models.version.encoderHiddenSize)+ XCTAssertEqual(SettingsStore.shared.selectedSpeechModel, selection)+ await manager.cleanup()+ } catch {+ await manager.cleanup()+ throw error+ }+ }+ #else+ throw XCTSkip("Compact Parakeet models require Apple silicon")+ #endif+ }+}++private actor RuntimeCheckActivity {+ private(set) var finished = false+ func finish() { self.finished = true }+}diff --git a/Tests/FluidDictationIntegrationTests/ParakeetSpeechModelCatalogTests.swift b/Tests/FluidDictationIntegrationTests/ParakeetSpeechModelCatalogTests.swiftnew file mode 100644index 00000000..39dc6ae6--- /dev/null+++ b/Tests/FluidDictationIntegrationTests/ParakeetSpeechModelCatalogTests.swift@@ -0,0 +1,308 @@+@testable import FluidVoice_Debug+import Foundation+import XCTest++@MainActor+final class ParakeetSpeechModelCatalogTests: XCTestCase {+ func testManifestIdentityReadIsBoundedAndRejectsLinksWithoutChangingArchiveMarker() throws {+ let descriptor = ParakeetSpeechModelCatalog.mini+ let directory = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString, isDirectory: true)+ defer { try? FileManager.default.removeItem(at: directory) }+ try FileManager.default.createDirectory(at: directory, withIntermediateDirectories: true)+ let marker = directory.appendingPathComponent(ParakeetSpeechModelCatalog.installationRevisionFileName)+ let oldHash = String(repeating: "a", count: 64)+ try Data(oldHash.utf8).write(to: marker)+ let manifest = directory.appendingPathComponent("manifest.json")+ XCTAssertNil(descriptor.installedManifestSHA256(at: directory))+ try Data("{}".utf8).write(to: manifest)+ XCTAssertEqual(descriptor.installedManifestSHA256(at: directory), "44136fa355b3678a1146ad16f7e8649e94fb4fc21fe77e8310c060f61caaff8a")+ XCTAssertEqual(try Data(contentsOf: marker), Data(oldHash.utf8))+ try Data(repeating: 0, count: 1_048_577).write(to: manifest)+ XCTAssertNil(descriptor.installedManifestSHA256(at: directory))+ try FileManager.default.removeItem(at: manifest)+ try FileManager.default.createSymbolicLink(at: manifest, withDestinationURL: marker)+ XCTAssertNil(descriptor.installedManifestSHA256(at: directory))+ XCTAssertNil(ParakeetSpeechModelCatalog.v2.installedManifestSHA256(at: directory))+ XCTAssertEqual(try Data(contentsOf: marker), Data(oldHash.utf8))+ }++ func testInstalledCompactRevisionCanBeOlderButMustHaveCompleteRegularArtifacts() throws {+ let descriptor = ParakeetSpeechModelCatalog.mini+ let directory = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString, isDirectory: true)+ defer { try? FileManager.default.removeItem(at: directory) }+ try FileManager.default.createDirectory(at: directory, withIntermediateDirectories: true)+ for model in descriptor.requiredModelNames {+ let root = directory.appendingPathComponent(model)+ try FileManager.default.createDirectory(at: root.appendingPathComponent("weights"), withIntermediateDirectories: true)+ for file in ["coremldata.bin", "metadata.json", "weights/weight.bin"] {+ try Data("fixture".utf8).write(to: root.appendingPathComponent(file))+ }+ }+ try Data("{}".utf8).write(to: directory.appendingPathComponent(descriptor.vocabularyFile))+ let oldHash = "12109f89c80b959847ac80ae963714a00af08f029144c3e4a2a8c1641f528a36"+ let marker = directory.appendingPathComponent(ParakeetSpeechModelCatalog.installationRevisionFileName)+ try Data(oldHash.utf8).write(to: marker)+ XCTAssertEqual(descriptor.installedArchiveSHA256(at: directory), oldHash)+ XCTAssertFalse(descriptor.artifactsAreComplete(at: directory), "A usable old checkpoint is not the latest installation")+ let link = directory.appendingPathComponent("unexpected-link")+ try FileManager.default.createSymbolicLink(at: link, withDestinationURL: marker)+ XCTAssertNil(descriptor.installedArchiveSHA256(at: directory))+ try FileManager.default.removeItem(at: link)+ for invalid in [String(repeating: "g", count: 64), String(repeating: "a", count: 65), ""] {+ try Data(invalid.utf8).write(to: marker)+ XCTAssertNil(descriptor.installedArchiveSHA256(at: directory))+ }+ try Data(oldHash.utf8).write(to: marker)+ try FileManager.default.removeItem(at: directory.appendingPathComponent("Encoder-1.mlmodelc/weights/weight.bin"))+ XCTAssertNil(descriptor.installedArchiveSHA256(at: directory))+ XCTAssertNil(ParakeetSpeechModelCatalog.v2.installedArchiveSHA256(at: directory))+ }++ func testInstalledPronunciationDescriptorIsOnlyALocalCandidate() throws {+ let oldHash = "12109f89c80b959847ac80ae963714a00af08f029144c3e4a2a8c1641f528a36"+ let key = ParakeetSpeechModelCatalog.mini.modelID + ":sha256:" + oldHash+ let candidate = try XCTUnwrap(ParakeetSpeechModelCatalog.descriptor(forInstalledPronunciationModelKey: key))+ XCTAssertEqual(candidate.pronunciationModelKey, key)+ XCTAssertEqual(candidate.archiveSHA256, oldHash)+ XCTAssertNil(candidate.archiveURL, "An old checkpoint may never be downloaded from the latest archive URL")+ XCTAssertEqual(candidate.requiredModelNames, ParakeetSpeechModelCatalog.mini.requiredModelNames)+ XCTAssertNil(ParakeetSpeechModelCatalog.descriptor(forPronunciationModelKey: key))+ XCTAssertTrue(ParakeetSpeechModelCatalog.isOutdatedCompactPronunciationModelKey(key))+ for invalid in [ParakeetSpeechModelCatalog.mini.modelID, key + "x", "fluid-parakeet-mini:sha256:" + String(repeating: "G", count: 64)] {+ XCTAssertNil(ParakeetSpeechModelCatalog.descriptor(forInstalledPronunciationModelKey: invalid))+ }+ XCTAssertEqual(ParakeetSpeechModelCatalog.descriptor(forInstalledPronunciationModelKey: "parakeet-v2"), ParakeetSpeechModelCatalog.v2)+ }++ func testAllOfflineParakeetVariantsHaveIndependentStableCacheAndPronunciationKeys() throws {+ let descriptors = ParakeetSpeechModelCatalog.descriptors+ XCTAssertEqual(Set(descriptors.map(\.variant)), Set(ParakeetSpeechModelCatalog.Variant.allCases))+ XCTAssertEqual(Set(descriptors.map(\.modelID)).count, 4)+ XCTAssertEqual(Set(descriptors.map(\.folderName)).count, 4)+ XCTAssertEqual(Set(descriptors.map(\.pronunciationModelKey)).count, 4)+ let root = URL(fileURLWithPath: "/fixture/FluidAudio/Models", isDirectory: true)+ for descriptor in descriptors {+ let model = try XCTUnwrap(SettingsStore.SpeechModel(rawValue: descriptor.modelID))+ XCTAssertEqual(model.parakeetDescriptor, descriptor)+ XCTAssertEqual(ParakeetSpeechModelCatalog.descriptor(for: descriptor.variant), descriptor)+ XCTAssertEqual(descriptor.cacheDirectory(in: root).deletingLastPathComponent(), root)+ XCTAssertEqual(descriptor.cacheDirectory(in: root).lastPathComponent, descriptor.folderName)+ XCTAssertEqual(model.expectedDownloadBytes, descriptor.expectedDownloadBytes)+ XCTAssertEqual(model.displayName, descriptor.displayName)+ XCTAssertEqual(model.humanReadableName, descriptor.humanReadableName)+ XCTAssertFalse(model.isWhisperModel)+ XCTAssertEqual(model.provider, .nvidia)+ XCTAssertTrue(model.requiresAppleSilicon)+ XCTAssertEqual(model.requiresMacOS15, model == .fluidParakeetMini || model == .fluidParakeetPico)+ XCTAssertFalse(model.requiresMacOS26)+ XCTAssertNil(model.whisperModelFile)+ XCTAssertNil(model.legacyWhisperModelFile)+ XCTAssertEqual(try JSONDecoder().decode(SettingsStore.SpeechModel.self, from: JSONEncoder().encode(model)), model)+ }+ XCTAssertNil(ParakeetSpeechModelCatalog.descriptor(forModelID: "missing"))+ XCTAssertNil(SettingsStore.SpeechModel.parakeetRealtime.parakeetDescriptor)+ XCTAssertNil(SettingsStore.SpeechModel.whisperBase.parakeetDescriptor)+ }++ func testLegacyV2V3IdentityAndArchitectureDefaultRemainUnchanged() {+ let v2 = ParakeetSpeechModelCatalog.v2+ let v3 = ParakeetSpeechModelCatalog.v3+ XCTAssertEqual(v2.modelID, "parakeet-tdt-v2")+ XCTAssertEqual(v3.modelID, "parakeet-tdt")+ XCTAssertEqual(v2.folderName, "parakeet-tdt-0.6b-v2-coreml")+ XCTAssertEqual(v3.folderName, "parakeet-tdt-0.6b-v3-coreml")+ XCTAssertEqual(v2.pronunciationModelKey, "parakeet-v2")+ XCTAssertEqual(v3.pronunciationModelKey, "parakeet-v3")+ XCTAssertEqual(v2.expectedDownloadBytes, 464_421_712)+ XCTAssertEqual(v3.expectedDownloadBytes, 483_288_717)+ XCTAssertEqual(v2.downloadSize, "~442.9 MiB")+ XCTAssertEqual(v3.downloadSize, "~460.9 MiB")+ XCTAssertEqual(SettingsStore.SpeechModel.parakeetTDTv2.humanReadableName, "Blazing Fast - English")+ XCTAssertEqual(SettingsStore.SpeechModel.parakeetTDT.humanReadableName, "Blazing Fast - Multilingual")+ XCTAssertEqual(SettingsStore.SpeechModel.parakeetTDTv2.accuracyPercent, 0.96)+ XCTAssertEqual(SettingsStore.SpeechModel.parakeetTDT.accuracyPercent, 0.92)+ XCTAssertEqual(SettingsStore.SpeechModel.parakeetTDTv2.speedPercent, 0.99)+ XCTAssertEqual(SettingsStore.SpeechModel.parakeetTDT.speedPercent, 0.99)+ XCTAssertTrue(SettingsStore.SpeechModel.parakeetTDTv2.hasPerformanceRatings)+ XCTAssertTrue(SettingsStore.SpeechModel.parakeetTDT.hasPerformanceRatings)+ for model: SettingsStore.SpeechModel in [.parakeetTDT, .parakeetTDTv2, .parakeetRealtime, .nemotronOffline, .nemotronStreaming] {+ XCTAssertEqual(model.brandName, "NVIDIA")+ XCTAssertEqual(model.brandColorHex, "#76B900")+ XCTAssertEqual(model.provider, .nvidia)+ }+ XCTAssertNil(v2.archiveURL)+ XCTAssertNil(v3.archiveSHA256)+ XCTAssertEqual(Set(v2.requiredModelNames), Set(["Preprocessor.mlmodelc", "Encoder.mlmodelc", "Decoder.mlmodelc", "JointDecision.mlmodelc"]))+ XCTAssertEqual(v2.requiredModelNames, v3.requiredModelNames)+ XCTAssertEqual(v2.supportedLanguageCodes, ["en"])+ XCTAssertEqual(Set(v3.supportedLanguageCodes), Set([+ "bg", "hr", "cs", "da", "nl", "en", "et", "fi", "fr", "de", "el", "hu", "it",+ "lv", "lt", "mt", "pl", "pt", "ro", "sk", "sl", "es", "sv", "ru", "uk",+ ]))+ XCTAssertEqual(SettingsStore.SpeechModel.defaultModel, CPUArchitecture.isAppleSilicon ? .parakeetTDT : .whisperBase)+ }++ func testHostedSmallVariantsUseExactArchivesAndNoInventedPerformanceRatings() throws {+ let fixtures: [(SettingsStore.SpeechModel, Int64, String, String)] = [+ (.fluidParakeetMini, 254_136_320, "fluid-mini", "7f811554cc670ded812937502f928ae6aad946bbf6e4c2eecd6fcffbe76f4d16"),+ (.fluidParakeetPico, 161_208_320, "fluid-pico", "542f74f639438bf37ff134a7a75daddb50d301deb87696994e11ff272df21512"),+ ]+ for (model, bytes, path, hash) in fixtures {+ let descriptor = try XCTUnwrap(model.parakeetDescriptor)+ XCTAssertEqual(descriptor.expectedDownloadBytes, bytes)+ XCTAssertEqual(descriptor.archiveSHA256, hash)+ XCTAssertEqual(descriptor.archiveURL?.absoluteString, "https://models.fluidvoice.app/parakeet/\(path)/1.1.1/\(descriptor.folderName).tar")+ XCTAssertEqual(descriptor.archiveURL?.scheme, "https")+ XCTAssertEqual(descriptor.supportedLanguageCodes, ["en"])+ XCTAssertTrue(descriptor.isEnglishOnly)+ XCTAssertEqual(model.languageSupport, "English Only")+ XCTAssertEqual(model.brandName, "FluidVoice")+ XCTAssertEqual(model.brandColorHex, "#1A75FF")+ XCTAssertEqual(model.provider, .nvidia, "Product branding must not change the Parakeet backend or family filter")+ XCTAssertFalse(model.usesAppleLogo)+ XCTAssertEqual(model.supportedLanguageCodes, "EN")+ XCTAssertEqual(model.supportedLanguageNames, "English")+ XCTAssertTrue(model.hasPerformanceRatings)+ XCTAssertNotNil(descriptor.performanceRatings)+ XCTAssertEqual(descriptor.attribution, "NVIDIA Parakeet · Moondream Parakeet Ultra")+ XCTAssertEqual(descriptor.creditLine, "Made by FluidVoice, built on NVIDIA Parakeet and Moondream’s Parakeet Ultra.")+ XCTAssertEqual(model.accuracyPercent, model == .fluidParakeetMini ? 0.95 : 0.91)+ XCTAssertEqual(model.speedPercent, model == .fluidParakeetMini ? 0.99 : 1.0)+ XCTAssertTrue(model.supportsPronunciationMatching, "Real split encoders produce compatible 1024-dimensional embeddings")+ XCTAssertTrue(model.supportsCustomVocabulary, "Real CTC110m boosting is verified for both variants")+ XCTAssertEqual(model.streamingPreviewIntervalSeconds, SettingsStore.SpeechModel.parakeetTDTv2.streamingPreviewIntervalSeconds)+ XCTAssertEqual(model.minimumStreamingPreviewSeconds, SettingsStore.SpeechModel.parakeetTDTv2.minimumStreamingPreviewSeconds)+ XCTAssertEqual(SettingsStore.SpeechModel.availableModels.contains(model), CPUArchitecture.isAppleSilicon)+ }+ XCTAssertEqual(SettingsStore.SpeechModel.fluidParakeetMini.humanReadableName, "Fluid Speech Mini")+ XCTAssertEqual(SettingsStore.SpeechModel.fluidParakeetPico.humanReadableName, "Fluid Speech Pico")+ }++ func testSmallVariantsAreOfferedOnlyForEnglishAndDoNotReplaceExistingFirstChoice() {+ let models: [SettingsStore.SpeechModel] = [.parakeetTDTv2, .parakeetRealtime, .parakeetTDT, .fluidParakeetMini, .fluidParakeetPico]+ let english = VoiceEngineLanguageCatalog.routes(forLanguageID: "en", availableModels: models)+ XCTAssertEqual(english.map(\.model), models)+ XCTAssertEqual(english.first?.model, .parakeetTDTv2)+ for route in english where route.model == .fluidParakeetMini || route.model == .fluidParakeetPico {+ XCTAssertEqual(route.binding, .automatic)+ XCTAssertNotNil(route.badgeText)+ }+ for language in VoiceEngineLanguageCatalog.allLanguages(availableModels: models) where language.id != "en" {+ let routes = VoiceEngineLanguageCatalog.routes(for: language, availableModels: models)+ XCTAssertFalse(routes.contains { $0.model == .fluidParakeetMini || $0.model == .fluidParakeetPico })+ XCTAssertEqual(routes.map(\.model), [.parakeetTDT])+ }+ XCTAssertEqual(VoiceEngineLanguageCatalog.allLanguages(availableModels: [.fluidParakeetMini, .fluidParakeetPico]).map(\.id), ["en"])+ XCTAssertTrue(VoiceEngineLanguageCatalog.routes(forLanguageID: "fr", availableModels: [.fluidParakeetMini, .fluidParakeetPico]).isEmpty)+ XCTAssertTrue(VoiceEngineLanguageCatalog.routes(forLanguageID: "missing", availableModels: models).isEmpty)+ }++ func testEnglishOnboardingShowsV2AndMiniWithoutChangingSelectionOrAvailableRoutes() {+ let language = VoiceEngineLanguage(id: "en", displayName: "English", aliases: [], isPopular: true)+ let models: [SettingsStore.SpeechModel] = [.parakeetTDTv2, .parakeetRealtime, .parakeetTDT, .fluidParakeetMini, .fluidParakeetPico, .appleSpeechAnalyzer, .appleSpeech, .whisperBase]+ let available = models.map { VoiceEngineLanguageRoute(language: language, model: $0, binding: .automatic) }+ let selection = SettingsStore.shared.selectedSpeechModel+ let displayed = OnboardingModelRecommendation.defaultRoutes(forLanguageID: "en", from: available)+ XCTAssertEqual(displayed.map(\.model), [.parakeetTDTv2, .fluidParakeetMini])+ XCTAssertEqual(displayed.first, available.first, "The established first recommendation must stay unchanged")+ let displayedIDs = Set(displayed.map(\.id))+ let other = available.filter { !displayedIDs.contains($0.id) }+ XCTAssertEqual(other.map(\.model), [.parakeetRealtime, .parakeetTDT, .fluidParakeetPico, .appleSpeechAnalyzer, .appleSpeech, .whisperBase])+ XCTAssertEqual(available.map(\.model), models)+ XCTAssertEqual(Set((displayed + other).map(\.id)), Set(available.map(\.id)))+ XCTAssertEqual(SettingsStore.shared.selectedSpeechModel, selection)+ XCTAssertEqual(ParakeetSpeechModelCatalog.mini.cardDescription, "Clear dictation in noisy places, at half the size of Blazing Fast. Runs on your Mac.")+ XCTAssertEqual(ParakeetSpeechModelCatalog.pico.cardDescription, "Our smallest model. Light enough for older Macs, and still clear in noisy places.")+ }++ func testOnboardingRecommendationsPreserveUnavailableMiniIntelAndNonEnglishFallbacks() {+ let english = VoiceEngineLanguage(id: "en", displayName: "English", aliases: [], isPopular: true)+ func routes(_ models: [SettingsStore.SpeechModel]) -> [VoiceEngineLanguageRoute] {+ models.map { VoiceEngineLanguageRoute(language: english, model: $0, binding: .automatic) }+ }+ let oldOS = routes([.parakeetTDTv2, .parakeetTDT, .appleSpeech])+ XCTAssertEqual(OnboardingModelRecommendation.defaultRoutes(forLanguageID: "en", from: oldOS).map(\.model), [.parakeetTDTv2, .appleSpeech])+ let intel = routes([.whisperBase, .appleSpeechAnalyzer, .appleSpeech])+ XCTAssertEqual(OnboardingModelRecommendation.defaultRoutes(forLanguageID: "en", from: intel).map(\.model), [.whisperBase, .appleSpeechAnalyzer])+ let appleFirst = routes([.appleSpeech, .whisperBase])+ XCTAssertEqual(OnboardingModelRecommendation.defaultRoutes(forLanguageID: "en", from: appleFirst), [appleFirst[0]], "Do not duplicate the built-in card")+ let withoutV2 = routes([.parakeetTDT, .fluidParakeetMini, .appleSpeech])+ XCTAssertEqual(OnboardingModelRecommendation.defaultRoutes(forLanguageID: "en", from: withoutV2).map(\.model), [.parakeetTDT, .appleSpeech])+ let french = VoiceEngineLanguage(id: "fr", displayName: "French", aliases: [], isPopular: true)+ let frenchRoutes = [.parakeetTDT, SettingsStore.SpeechModel.appleSpeech].map {+ VoiceEngineLanguageRoute(language: french, model: $0, binding: .automatic)+ }+ XCTAssertEqual(OnboardingModelRecommendation.defaultRoutes(forLanguageID: "fr", from: frenchRoutes), [frenchRoutes[0]])+ XCTAssertTrue(OnboardingModelRecommendation.defaultRoutes(forLanguageID: "en", from: []).isEmpty)+ XCTAssertTrue(OnboardingModelRecommendation.defaultRoutes(forLanguageID: "fr", from: []).isEmpty)+ let onlyMini = routes([.fluidParakeetMini])+ XCTAssertEqual(OnboardingModelRecommendation.defaultRoutes(forLanguageID: "en", from: onlyMini), onlyMini)+ }++ func testCatalogReadsPreserveExistingAndNewPersistedSelections() throws {+ let defaults = UserDefaults.standard+ let domain = try XCTUnwrap(Bundle.main.bundleIdentifier)+ let original = defaults.persistentDomain(forName: domain)+ defer {+ if let original {+ defaults.setPersistentDomain(original, forName: domain)+ } else {+ defaults.removePersistentDomain(forName: domain)+ }+ }+ let settings = SettingsStore.shared+ let models: [SettingsStore.SpeechModel] = [.parakeetTDT, .parakeetTDTv2, .fluidParakeetMini, .fluidParakeetPico, .whisperBase]+ for model in models {+ // A direct persisted fixture avoids sending model-switch UI events.+ defaults.set(model.rawValue, forKey: "SelectedSpeechModel")+ let before = defaults.persistentDomain(forName: domain)+ _ = model.parakeetDescriptor+ _ = model.displayName+ _ = model.expectedDownloadBytes+ _ = SettingsStore.SpeechModel.availableModels+ let expected = model.requiresAppleSilicon && !CPUArchitecture.isAppleSilicon ? SettingsStore.SpeechModel.whisperBase : model+ XCTAssertEqual(settings.selectedSpeechModel, expected)+ XCTAssertEqual(defaults.string(forKey: "SelectedSpeechModel"), model.rawValue)+ XCTAssertEqual(defaults.persistentDomain(forName: domain) as NSDictionary?, before as NSDictionary?)+ }+ }++ func testSplitCompletenessRequiresEveryEncoderPartAndVocabularyWithoutBorrowingSiblingCache() throws {+ let root = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString, isDirectory: true)+ defer { try? FileManager.default.removeItem(at: root) }+ let mini = ParakeetSpeechModelCatalog.mini+ let pico = ParakeetSpeechModelCatalog.pico+ let miniDirectory = mini.cacheDirectory(in: root)+ try self.installFixture(mini, at: miniDirectory)+ XCTAssertTrue(mini.artifactsAreComplete(at: miniDirectory))+ XCTAssertFalse(pico.artifactsAreComplete(at: pico.cacheDirectory(in: root)))+ let encoder = miniDirectory.appendingPathComponent("Encoder-3.mlmodelc", isDirectory: true)+ try FileManager.default.removeItem(at: encoder)+ XCTAssertFalse(mini.artifactsAreComplete(at: miniDirectory))+ try self.installCompiledFixture(at: encoder)+ let vocabulary = miniDirectory.appendingPathComponent(mini.vocabularyFile)+ try Data().write(to: vocabulary)+ XCTAssertFalse(mini.artifactsAreComplete(at: miniDirectory))+ try Data("{}".utf8).write(to: vocabulary)+ XCTAssertTrue(mini.artifactsAreComplete(at: miniDirectory))+ let weights = encoder.appendingPathComponent("weights/weight.bin")+ try Data().write(to: weights)+ XCTAssertFalse(mini.artifactsAreComplete(at: miniDirectory))+ }++ private func installFixture(_ descriptor: ParakeetSpeechModelCatalog.Descriptor, at directory: URL) throws {+ try FileManager.default.createDirectory(at: directory, withIntermediateDirectories: true)+ try Data("{}".utf8).write(to: directory.appendingPathComponent(descriptor.vocabularyFile))+ for name in descriptor.requiredModelNames {+ try self.installCompiledFixture(at: directory.appendingPathComponent(name, isDirectory: true))+ }+ try descriptor.writeInstallationRevision(at: directory)+ }++ private func installCompiledFixture(at directory: URL) throws {+ try FileManager.default.createDirectory(at: directory.appendingPathComponent("weights", isDirectory: true), withIntermediateDirectories: true)+ try Data([1]).write(to: directory.appendingPathComponent("coremldata.bin"))+ try Data("{}".utf8).write(to: directory.appendingPathComponent("metadata.json"))+ try Data([1]).write(to: directory.appendingPathComponent("weights/weight.bin"))+ }+}diff --git a/Tests/FluidDictationIntegrationTests/ProgressiveFileDownloaderTests.swift b/Tests/FluidDictationIntegrationTests/ProgressiveFileDownloaderTests.swiftnew file mode 100644index 00000000..7ccca49d--- /dev/null+++ b/Tests/FluidDictationIntegrationTests/ProgressiveFileDownloaderTests.swift@@ -0,0 +1,99 @@+@testable import FluidVoice_Debug+import Foundation+import XCTest++/// Exercises the real delegate without starting a network task.+final nonisolated class ProgressiveFileDownloaderTests: XCTestCase {+ func testOversizedChunkedTransferStopsBeforeReportingMisleadingProgress() throws {+ try self.assertRejected(written: 11, expected: -1, maximum: 10)+ }++ func testOversizedDeclaredResponseStopsAtFirstByteCallback() throws {+ try self.assertRejected(written: 1, expected: 11, maximum: 10)+ }++ func testExactLimitAndDefaultUnlimitedDownloadsStillReturnTheirFile() throws {+ for maximum: Int64? in [3, nil] {+ let fixture = try Fixture(maximumBytes: maximum)+ defer { fixture.cleanup() }+ fixture.delegate.urlSession(fixture.session, downloadTask: fixture.task, didWriteData: 3, totalBytesWritten: 3, totalBytesExpectedToWrite: 3)+ fixture.delegate.retainDownload(at: fixture.source, response: fixture.response)+ fixture.delegate.urlSession(fixture.session, task: fixture.task, didCompleteWithError: nil)+ let result = try XCTUnwrap(fixture.recorder.result).get()+ defer { try? FileManager.default.removeItem(at: result.0) }+ XCTAssertEqual(try Data(contentsOf: result.0), Data([1, 2, 3]))+ XCTAssertEqual(fixture.recorder.progress, [3])+ }+ }++ func testFinishedOversizedFileIsNeverRetainedEvenWithoutProgressCallback() throws {+ let fixture = try Fixture(maximumBytes: 2)+ defer { fixture.cleanup() }+ fixture.delegate.retainDownload(at: fixture.source, response: fixture.response)+ fixture.delegate.urlSession(fixture.session, task: fixture.task, didCompleteWithError: nil)+ self.assertLengthFailure(fixture.recorder.result)+ XCTAssertTrue(FileManager.default.fileExists(atPath: fixture.source.path))+ }++ func testCancellationAfterFileCompletionRemovesRetainedDownload() throws {+ let fixture = try Fixture(maximumBytes: nil)+ defer { fixture.cleanup() }+ let retained = try XCTUnwrap(fixture.delegate.retainDownload(at: fixture.source, response: fixture.response))+ XCTAssertTrue(FileManager.default.fileExists(atPath: retained.path))+ fixture.delegate.urlSession(fixture.session, task: fixture.task, didCompleteWithError: URLError(.cancelled))+ XCTAssertFalse(FileManager.default.fileExists(atPath: retained.path))+ guard case let .failure(error)? = fixture.recorder.result else { return XCTFail("Expected cancellation") }+ XCTAssertEqual((error as? URLError)?.code, .cancelled)+ }++ private func assertRejected(written: Int64, expected: Int64, maximum: Int64) throws {+ let fixture = try Fixture(maximumBytes: maximum)+ defer { fixture.cleanup() }+ fixture.delegate.urlSession(fixture.session, downloadTask: fixture.task, didWriteData: written, totalBytesWritten: written, totalBytesExpectedToWrite: expected)+ fixture.delegate.urlSession(fixture.session, task: fixture.task, didCompleteWithError: URLError(.cancelled))+ self.assertLengthFailure(fixture.recorder.result)+ XCTAssertTrue(fixture.recorder.progress.isEmpty)+ }++ private func assertLengthFailure(_ result: Result<(URL, URLResponse), Error>?, file: StaticString = #filePath, line: UInt = #line) {+ guard case let .failure(error)? = result else { return XCTFail("Expected oversized transfer rejection", file: file, line: line) }+ XCTAssertEqual((error as? URLError)?.code, .dataLengthExceedsMaximum, file: file, line: line)+ }++ private final class Recorder: @unchecked Sendable {+ private let lock = NSLock()+ private var storedResult: Result<(URL, URLResponse), Error>?+ private var storedProgress: [Int64] = []+ var result: Result<(URL, URLResponse), Error>? { self.lock.withLock { self.storedResult } }+ var progress: [Int64] { self.lock.withLock { self.storedProgress } }+ func complete(_ result: Result<(URL, URLResponse), Error>) { self.lock.withLock { self.storedResult = result } }+ func report(_ bytes: Int64, _: Int64) { self.lock.withLock { self.storedProgress.append(bytes) } }+ }++ private struct Fixture {+ let directory: URL+ let source: URL+ let session: URLSession+ let task: URLSessionDownloadTask+ let response: URLResponse+ let delegate: ProgressiveFileDownloader.Delegate+ let recorder: Recorder++ init(maximumBytes: Int64?) throws {+ self.directory = FileManager.default.temporaryDirectory.appendingPathComponent("ProgressiveFileDownloaderTests-" + UUID().uuidString)+ try FileManager.default.createDirectory(at: self.directory, withIntermediateDirectories: false)+ self.source = self.directory.appendingPathComponent("transfer")+ try Data([1, 2, 3]).write(to: self.source)+ self.recorder = Recorder()+ self.delegate = ProgressiveFileDownloader.Delegate(maximumBytes: maximumBytes, onProgress: self.recorder.report, completion: self.recorder.complete)+ self.session = URLSession(configuration: .ephemeral)+ self.task = try self.session.downloadTask(with: XCTUnwrap(URL(string: "https://fixture.invalid/unused")))+ self.response = URLResponse(url: self.source, mimeType: nil, expectedContentLength: 3, textEncodingName: nil)+ }++ func cleanup() {+ self.session.invalidateAndCancel()+ try? FileManager.default.removeItem(at: self.directory)+ }+ }+}diff --git a/Tests/FluidDictationIntegrationTests/PronunciationModelRevisionTests.swift b/Tests/FluidDictationIntegrationTests/PronunciationModelRevisionTests.swiftnew file mode 100644index 00000000..93a299c3--- /dev/null+++ b/Tests/FluidDictationIntegrationTests/PronunciationModelRevisionTests.swift@@ -0,0 +1,193 @@+@testable import FluidVoice_Debug+import Foundation+import XCTest++@MainActor+final class PronunciationModelRevisionTests: XCTestCase {+ func testCurrentCompactKeysIncludeFullPinnedHashAndLegacyKeysStayExact() throws {+ XCTAssertEqual(ParakeetSpeechModelCatalog.v2.pronunciationModelKey, "parakeet-v2")+ XCTAssertEqual(ParakeetSpeechModelCatalog.v3.pronunciationModelKey, "parakeet-v3")+ for descriptor in [ParakeetSpeechModelCatalog.mini, ParakeetSpeechModelCatalog.pico] {+ let hash = try XCTUnwrap(descriptor.archiveSHA256)+ XCTAssertEqual(descriptor.pronunciationModelKey, descriptor.modelID + ":sha256:" + hash)+ XCTAssertEqual(ParakeetSpeechModelCatalog.descriptor(forPronunciationModelKey: descriptor.pronunciationModelKey), descriptor)+ XCTAssertNil(ParakeetSpeechModelCatalog.descriptor(forPronunciationModelKey: descriptor.modelID))+ XCTAssertTrue(ParakeetSpeechModelCatalog.isOutdatedCompactPronunciationModelKey(descriptor.modelID))+ let old = descriptor.modelID + ":sha256:" + String(repeating: "0", count: 64)+ XCTAssertNil(ParakeetSpeechModelCatalog.descriptor(forPronunciationModelKey: old))+ XCTAssertTrue(ParakeetSpeechModelCatalog.isOutdatedCompactPronunciationModelKey(old))+ XCTAssertFalse(ParakeetSpeechModelCatalog.isOutdatedCompactPronunciationModelKey(descriptor.pronunciationModelKey))+ }+ XCTAssertEqual(ParakeetSpeechModelCatalog.descriptor(forPronunciationModelKey: "parakeet-v2"), ParakeetSpeechModelCatalog.v2)+ XCTAssertEqual(ParakeetSpeechModelCatalog.descriptor(forPronunciationModelKey: "parakeet-v3"), ParakeetSpeechModelCatalog.v3)+ XCTAssertFalse(ParakeetSpeechModelCatalog.isOutdatedCompactPronunciationModelKey("parakeet-v3"))+ }++ func testRetrainingKeepsOriginalStoredProfileAndTextEntryWithoutReusingOldVectors() async throws {+ let directory = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)+ defer { try? FileManager.default.removeItem(at: directory) }+ let store = PronunciationDictionaryStore(fileURL: directory.appendingPathComponent("profiles.json"))+ let descriptor = ParakeetSpeechModelCatalog.mini+ let entry = SettingsStore.CustomDictionaryEntry(triggers: ["fluid boys"], replacement: "FluidVoice")+ let originalEntry = entry+ let old = Self.profile(entryID: entry.id, key: descriptor.modelID)+ try await store.upsert(dictionaryEntryID: entry.id, label: old.label, modelKey: old.modelKey, enrollments: old.enrollments)+ let original = await store.allProfiles()+ let currentBeforeRetraining = await store.profiles(modelKey: descriptor.pronunciationModelKey)+ XCTAssertTrue(currentBeforeRetraining.isEmpty)+ #if arch(arm64)+ XCTAssertTrue(DictionaryPronunciationReferences.make(profiles: original).isEmpty)+ #endif+ let current = Self.profile(entryID: entry.id, key: descriptor.pronunciationModelKey)+ try await store.upsert(dictionaryEntryID: entry.id, label: current.label, modelKey: current.modelKey, enrollments: current.enrollments)+ let all = await store.allProfiles()+ let stillSaved = all.filter { $0.modelKey == old.modelKey }+ XCTAssertEqual(stillSaved, original)+ XCTAssertEqual(all.count, 2)+ XCTAssertEqual(entry, originalEntry, "Revision checks must not change basic text corrections")+ let compatible = await store.profiles(modelKey: descriptor.pronunciationModelKey)+ XCTAssertEqual(compatible.count, 1)+ XCTAssertEqual(compatible[0].enrollments.map(\.modelKey), Array(repeating: descriptor.pronunciationModelKey, count: 3))+ #if arch(arm64)+ XCTAssertEqual(DictionaryPronunciationReferences.make(profiles: all).count, 3)+ for key in ["parakeet-v2", "parakeet-v3"] {+ XCTAssertEqual(DictionaryPronunciationReferences.make(profiles: [Self.profile(entryID: entry.id, key: key)]).count, 3)+ }+ #endif+ }++ func testOldNegativeFramesAreInactiveAndRemainStoredWithoutAReadMutation() async throws {+ let directory = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)+ defer { try? FileManager.default.removeItem(at: directory) }+ let url = directory.appendingPathComponent("negative.plist")+ let store = DictionaryNegativeExampleStore(url: url, collectionEnabled: { true })+ let id = UUID()+ let oldKey = ParakeetSpeechModelCatalog.mini.modelID+ let currentKey = ParakeetSpeechModelCatalog.mini.pronunciationModelKey+ let frames = DictionaryMatchFrames(hiddenSize: 2, values: [1, 0, 1, 0])+ let evidence = DictionaryAcousticEvidence(id: UUID(), entryID: id, label: "FluidVoice", profileKey: "fixture", modelKey: oldKey, sourceWordRange: 0..<1, frames: frames)+ let revision = await store.revision()+ try await store.save(.init(evidence: evidence, correctedText: "different", expiresAt: Date().addingTimeInterval(60)), expectedRevision: revision)+ let before = try Data(contentsOf: url)+ let inactive = await store.frames(entryID: id, profileKey: "fixture", modelKey: oldKey)+ let current = await store.frames(entryID: id, profileKey: "fixture", modelKey: currentKey)+ XCTAssertTrue(inactive.isEmpty)+ XCTAssertTrue(current.isEmpty)+ XCTAssertEqual(try Data(contentsOf: url), before)+ let saved = try PropertyListDecoder().decode([DictionaryNegativeExampleStore.Example].self, from: before)+ XCTAssertEqual(saved.count, 1)+ XCTAssertEqual(saved[0].modelKey, oldKey)+ for key in [currentKey, "parakeet-v2", "parakeet-v3"] {+ let currentID = UUID()+ let currentEvidence = DictionaryAcousticEvidence(id: UUID(), entryID: currentID, label: "Current", profileKey: "current-fixture", modelKey: key, sourceWordRange: 0..<1, frames: frames)+ try await store.save(.init(evidence: currentEvidence, correctedText: "different", expiresAt: Date().addingTimeInterval(60)), expectedRevision: revision)+ let compatible = await store.frames(entryID: currentID, profileKey: "current-fixture", modelKey: key)+ XCTAssertEqual(compatible, [frames], "Current and legacy checkpoints must still use their own negative frames")+ }+ let after = try PropertyListDecoder().decode([DictionaryNegativeExampleStore.Example].self, from: Data(contentsOf: url))+ XCTAssertTrue(after.contains { $0.modelKey == oldKey }, "Reading inactive negatives must not silently erase them")+ }++ func testNoticeAndReplayAskToRetrainOnlyAffectedActiveWords() throws {+ let descriptor = ParakeetSpeechModelCatalog.mini+ let id = UUID()+ let old = Self.profile(entryID: id, key: descriptor.modelID)+ let current = Self.profile(entryID: id, key: descriptor.pronunciationModelKey)+ let notice = DictionaryPronunciationRevisionPolicy.notice(profiles: [old], descriptor: descriptor, entryIDs: [id])+ XCTAssertTrue(notice?.contains("FluidVoice") == true)+ XCTAssertTrue(notice?.contains("need retraining") == true)+ XCTAssertTrue(notice?.contains("text corrections remain saved") == true)+ XCTAssertNil(DictionaryPronunciationRevisionPolicy.notice(profiles: [old, current], descriptor: descriptor, entryIDs: [id]))+ XCTAssertNil(DictionaryPronunciationRevisionPolicy.notice(profiles: [old], descriptor: descriptor, entryIDs: []))+ XCTAssertNil(DictionaryPronunciationRevisionPolicy.notice(profiles: [old], descriptor: ParakeetSpeechModelCatalog.pico, entryIDs: [id]))+ XCTAssertNil(DictionaryPronunciationRevisionPolicy.notice(profiles: [old], descriptor: ParakeetSpeechModelCatalog.v3, entryIDs: [id]))+ XCTAssertThrowsError(try DictionaryMatchPlayground.targetProfile(from: [old], target: "fluidvoice")) { error in+ XCTAssertEqual(error as? PronunciationDictionaryStoreError, .outdatedModelRevision)+ XCTAssertTrue(error.localizedDescription.contains("Retrain this word"))+ }+ XCTAssertEqual(try DictionaryMatchPlayground.targetProfile(from: [old, current], target: "fluidvoice"), current)+ }++ #if arch(arm64)+ func testProfileCannotMixEnrollmentVectorsFromDifferentRevisions() {+ let current = ParakeetSpeechModelCatalog.mini.pronunciationModelKey+ var profile = Self.profile(entryID: UUID(), key: current)+ profile.enrollments[0] = PronunciationEnrollmentCapture(values: [1, 0], sourceFrameCount: 6, modelKey: ParakeetSpeechModelCatalog.mini.modelID)+ XCTAssertTrue(DictionaryPronunciationReferences.make(profiles: [profile]).isEmpty)+ }++ func testOldOriginalAudioEvidenceIsRejectedBeforeAnyModelLoad() async throws {+ let evidence = DictionaryLearningAudioEvidence(+ recordingID: UUID(),+ modelKey: ParakeetSpeechModelCatalog.mini.modelID,+ observedText: "fluid boys",+ sourceWordRange: 0..<1,+ sourceSampleRange: 0..<1,+ focalSampleRange: 0..<1,+ samples: [0.1]+ )+ do {+ _ = try await OriginalAudioEmbeddingExtractor.extract(evidence)+ XCTFail("Old revision evidence must never load the current encoder")+ } catch let error as PronunciationDictionaryStoreError {+ XCTAssertEqual(error, .outdatedModelRevision)+ }+ }+ #endif++ #if arch(arm64)+ func testLoadedOldCompactRevisionMatchesOnlyItsOwnEnrollmentVectors() {+ let descriptor = ParakeetSpeechModelCatalog.mini+ let oldKey = descriptor.modelID + ":sha256:" + String(repeating: "a", count: 64)+ let old = Self.profile(entryID: UUID(), key: oldKey)+ let latest = Self.profile(entryID: UUID(), key: descriptor.pronunciationModelKey)+ XCTAssertTrue(DictionaryPronunciationReferences.make(profiles: [old]).isEmpty)+ let oldReferences = DictionaryPronunciationReferences.make(profiles: [old, latest], compatibleModelKey: oldKey)+ XCTAssertEqual(oldReferences.count, 3)+ XCTAssertTrue(oldReferences.allSatisfy { $0.profile.modelKey == oldKey })+ let latestReferences = DictionaryPronunciationReferences.make(profiles: [old, latest], compatibleModelKey: descriptor.pronunciationModelKey)+ XCTAssertEqual(latestReferences.count, 3)+ XCTAssertTrue(latestReferences.allSatisfy { $0.profile.modelKey == descriptor.pronunciationModelKey })+ var mixed = old+ mixed.enrollments[0] = latest.enrollments[0]+ XCTAssertTrue(DictionaryPronunciationReferences.make(profiles: [mixed], compatibleModelKey: oldKey).isEmpty)+ let unversioned = Self.profile(entryID: UUID(), key: descriptor.modelID)+ XCTAssertTrue(DictionaryPronunciationReferences.make(profiles: [unversioned], compatibleModelKey: descriptor.modelID).isEmpty)+ }++ func testNormalProviderPreparationKeepsCompleteOldWeightsAndTheirActualPronunciationKey() async throws {+ let root = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString, isDirectory: true)+ defer { try? FileManager.default.removeItem(at: root) }+ for model: SettingsStore.SpeechModel in [.fluidParakeetMini, .fluidParakeetPico] {+ let descriptor = try XCTUnwrap(model.parakeetDescriptor)+ let installed = descriptor.cacheDirectory(in: root)+ try FileManager.default.createDirectory(at: installed, withIntermediateDirectories: true)+ let oldHash = String(repeating: "a", count: 64)+ try Data(oldHash.utf8).write(to: installed.appendingPathComponent(ParakeetSpeechModelCatalog.installationRevisionFileName))+ try Data("{}".utf8).write(to: installed.appendingPathComponent(descriptor.vocabularyFile))+ for name in descriptor.requiredModelNames {+ let folder = installed.appendingPathComponent(name)+ try FileManager.default.createDirectory(at: folder.appendingPathComponent("weights"), withIntermediateDirectories: true)+ for file in ["coremldata.bin", "metadata.json", "weights/weight.bin"] {+ try Data("fixture".utf8).write(to: folder.appendingPathComponent(file))+ }+ }+ XCTAssertEqual(descriptor.installedArchiveSHA256(at: installed), oldHash)+ let provider = FluidAudioProvider(modelOverride: model, configureWordBoosting: false)+ provider.modelCacheRootForTesting = root+ do {+ try await ASRService().prepareProviderRecoveryForTesting(provider, modelsAlreadyCached: true)+ XCTFail("Dummy Core ML files must fail locally without deleting old weights for recovery")+ } catch {}+ XCTAssertEqual(provider.pronunciationModelKeyForTesting, descriptor.modelID + ":sha256:" + oldHash)+ XCTAssertEqual(descriptor.installedArchiveSHA256(at: installed), oldHash, "Normal loading must never erase an older complete download")+ XCTAssertEqual(try Data(contentsOf: installed.appendingPathComponent(descriptor.vocabularyFile)), Data("{}".utf8))+ }+ }+ #endif++ private static func profile(entryID: UUID, key: String) -> PronunciationDictionaryProfile {+ let captures = Array(repeating: PronunciationEnrollmentCapture(values: [1, 0], sourceFrameCount: 6, modelKey: key), count: 3)+ return PronunciationDictionaryProfile(dictionaryEntryID: entryID, label: "FluidVoice", modelKey: key, hiddenSize: 2, enrollments: captures)+ }+}diff --git a/Tests/FluidDictationIntegrationTests/SearchIndexTests.swift b/Tests/FluidDictationIntegrationTests/SearchIndexTests.swiftindex b7bff1cb..234a677e 100644--- a/Tests/FluidDictationIntegrationTests/SearchIndexTests.swift+++ b/Tests/FluidDictationIntegrationTests/SearchIndexTests.swift@@ -1,3 +1,5 @@+import CryptoKit+import Darwin@testable import FluidVoice_Debugimport Foundationimport SQLite3@@ -87,6 +89,208 @@ final class SearchIndexTests: XCTestCase {XCTAssertEqual(new, [original.id])}+ func testLowerAndEqualRevisionsCannotReplaceNewerIndexedText() async throws {+ let latest = Self.record("latest harbour manuscript", revision: 9)+ try await self.index.reconcile(.history, with: [latest])+ for revision: UInt64 in [1, 9] {+ let stale = SearchIndexRecord(id: latest.id, revision: revision, timestamp: latest.timestamp, text: "obsolete lighthouse manuscript")+ let report = try await self.index.reconcile(.history, with: [stale])+ XCTAssertEqual(report, .init(upserted: 0, deleted: 0))+ let current = try await self.ids(.history, query: "harb")+ let replaced = try await self.ids(.history, query: "lighth")+ XCTAssertEqual(current, [latest.id])+ XCTAssertTrue(replaced.isEmpty)+ }+ }++ func testReconcilingOneKindDoesNotDeleteOrReplaceOtherNamespaces() async throws {+ let history = Self.record("harbour history")+ let transcript = SearchIndexRecord(id: history.id, revision: 17, timestamp: history.timestamp, text: "lighthouse transcript")+ let chat = SearchIndexRecord(id: history.id, revision: 30, timestamp: history.timestamp, text: "mountain chat")+ try await self.index.reconcile(.history, with: [history])+ try await self.index.reconcile(.transcripts, with: [transcript])+ try await self.index.reconcile(.chats, with: [chat])+ let report = try await self.index.reconcile(.history, with: [])+ XCTAssertEqual(report, .init(upserted: 0, deleted: 1))+ let historyCount = try await self.count(.history)+ let transcripts = try await self.ids(.transcripts, query: "lighth")+ let chats = try await self.ids(.chats, query: "mount")+ XCTAssertEqual(historyCount, 0)+ XCTAssertEqual(transcripts, [history.id])+ XCTAssertEqual(chats, [history.id])+ }++ func testSealedRecordOnlyNamespaceReopensWithoutBackfillAndKeepsPrefixMatches() async throws {+ XCTAssertNil(SearchIndex.spec.vectorSpace)+ XCTAssertTrue(SearchIndex.spec.attributes.isEmpty)+ let directory = self.root.appendingPathComponent("sealed", isDirectory: true)+ let records = [Self.record("meeting notes from monday"), Self.record("harbour lights at dusk")]+ let initialRoot = FluidZeppelinRoot(root: directory)+ let initial = SearchIndex(root: initialRoot)+ do {+ try await initial.reconcile(.history, with: records)+ let store = try await initial.namespace(.history)+ _ = try await store.seal()+ let sealed = try await store.stats()+ XCTAssertEqual(sealed.activeRowCount, 0, "Record-only rows must leave the active segment when sealed")+ } catch {+ await initialRoot.closeAll()+ throw error+ }+ await initialRoot.closeAll()++ // Distinct roots and actor handles exercise the actual reopen path, not+ // the cached namespace task from the first reconcile.+ for _ in 0..<3 {+ let reopenedRoot = FluidZeppelinRoot(root: directory)+ let reopened = SearchIndex(root: reopenedRoot)+ do {+ let report = try await reopened.reconcile(.history, with: records)+ XCTAssertEqual(report, .init(upserted: 0, deleted: 0))+ for typed in ["mee", "meetin", "notes mo"] {+ let hits = try await reopened.query(.history, text: typed, limit: 10)+ XCTAssertEqual(Set(hits.map(\.id)), [records[0].id])+ }+ let store = try await reopened.namespace(.history)+ let sealed = try await store.stats()+ XCTAssertEqual(sealed.activeRowCount, 0, "An unchanged reopen must not create a fresh active backfill")+ } catch {+ await reopenedRoot.closeAll()+ throw error+ }+ await reopenedRoot.closeAll()+ }+ }++ func testReopenedIndexAppliesInsertDeleteAndRestoredRevisionWithoutRevivingOldText() async throws {+ let directory = self.root.appendingPathComponent("revisions", isDirectory: true)+ let kept = Self.record("original harbour text", revision: 6)+ let removed = Self.record("removed lighthouse text", revision: 4)+ let initialRoot = FluidZeppelinRoot(root: directory)+ let initial = SearchIndex(root: initialRoot)+ do {+ try await initial.reconcile(.history, with: [kept, removed])+ let store = try await initial.namespace(.history)+ _ = try await store.seal()+ } catch {+ await initialRoot.closeAll()+ throw error+ }+ await initialRoot.closeAll()++ let reopenedRoot = FluidZeppelinRoot(root: directory)+ let reopened = SearchIndex(root: reopenedRoot)+ do {+ let restored = SearchIndexRecord(id: kept.id, revision: 7, timestamp: kept.timestamp, text: "restored mountain text")+ let inserted = Self.record("new river text")+ let report = try await reopened.reconcile(.history, with: [restored, inserted])+ XCTAssertEqual(report, .init(upserted: 2, deleted: 1))+ let restoredHits = try await reopened.query(.history, text: "mount", limit: 10)+ let insertedHits = try await reopened.query(.history, text: "riv", limit: 10)+ let oldHits = try await reopened.query(.history, text: "harbour", limit: 10)+ let deletedHits = try await reopened.query(.history, text: "lighthouse", limit: 10)+ XCTAssertEqual(Set(restoredHits.map(\.id)), [kept.id])+ XCTAssertEqual(Set(insertedHits.map(\.id)), [inserted.id])+ XCTAssertTrue(oldHits.isEmpty)+ XCTAssertTrue(deletedHits.isEmpty)+ } catch {+ await reopenedRoot.closeAll()+ throw error+ }+ await reopenedRoot.closeAll()+ }++ func testUnchangedLegacyBackfillSealsOnceAndSmallSubsequentWritesStayActive() async throws {+ let directory = self.root.appendingPathComponent("maintenance", isDirectory: true)+ let records = (0..<260).map { Self.record("maintenance harbour entry \($0)") }+ let legacyRoot = FluidZeppelinRoot(root: directory)+ let legacy = SearchIndex(root: legacyRoot, maintenanceActiveRowLimit: nil)+ do {+ try await legacy.reconcile(.history, with: records)+ let store = try await legacy.namespace(.history)+ let stats = try await store.stats()+ XCTAssertEqual(stats.activeRowCount, 260)+ } catch {+ await legacyRoot.closeAll()+ throw error+ }+ await legacyRoot.closeAll()++ let maintainedRoot = FluidZeppelinRoot(root: directory)+ let maintained = SearchIndex(root: maintainedRoot)+ do {+ let backfill = try await maintained.reconcile(.history, with: records)+ XCTAssertEqual(backfill, .init(upserted: 0, deleted: 0), "Sealing must not relabel unchanged records as new writes")+ let store = try await maintained.namespace(.history)+ let first = try await store.stats()+ XCTAssertEqual(first.activeRowCount, 0)+ XCTAssertGreaterThan(first.segmentBytes, 0)+ let repeated = try await maintained.reconcile(.history, with: records)+ let second = try await store.stats()+ XCTAssertEqual(repeated, .init(upserted: 0, deleted: 0))+ XCTAssertEqual(second.segmentBytes, first.segmentBytes, "An unchanged snapshot must not create another segment")+ XCTAssertEqual(second.activeRowCount, 0)++ let added = Self.record("one additional river entry")+ let insertion = try await maintained.reconcile(.history, with: records + [added])+ let smallWrite = try await store.stats()+ XCTAssertEqual(insertion, .init(upserted: 1, deleted: 0))+ XCTAssertEqual(smallWrite.activeRowCount, 1, "Do not seal after every dictation")+ let hits = try await maintained.query(.history, text: "additional riv", limit: 10)+ XCTAssertEqual(Set(hits.map(\.id)), [added.id])+ } catch {+ await maintainedRoot.closeAll()+ throw error+ }+ await maintainedRoot.closeAll()+ }++ func testFailedSealingPreservesSearchableRecordsAndRetriesOnNextSnapshot() async throws {+ let directory = self.root.appendingPathComponent("maintenance-failure", isDirectory: true)+ let namespace = directory.appendingPathComponent(SearchIndexKind.history.rawValue, isDirectory: true)+ let database = FluidZeppelinRoot(root: directory)+ let records = (0..<260).map { Self.record("permission harbour entry \($0)") }+ let legacy = SearchIndex(root: database, maintenanceActiveRowLimit: nil)+ do {+ try await legacy.reconcile(.history, with: records)+ // The live WAL handle stays writable; immutable segment publication+ // needs a new directory entry and must fail under these permissions.+ try FileManager.default.setAttributes([.posixPermissions: 0o500], ofItemAtPath: namespace.path)+ defer { try? FileManager.default.setAttributes([.posixPermissions: 0o700], ofItemAtPath: namespace.path) }+ let permissionProbe = namespace.appendingPathComponent("permission-probe")+ var deniesCreation = false+ do {+ try Data([0]).write(to: permissionProbe, options: .withoutOverwriting)+ } catch {+ deniesCreation = true+ }+ if !deniesCreation {+ try? FileManager.default.removeItem(at: permissionProbe)+ throw XCTSkip("The test runner can create files despite private directory permissions")+ }+ let maintained = SearchIndex(root: database)+ let report = try await maintained.reconcile(.history, with: records)+ XCTAssertEqual(report, .init(upserted: 0, deleted: 0), "Maintenance failure must not fail an otherwise successful reconcile")+ let store = try await maintained.namespace(.history)+ let failedStats = try await store.stats()+ XCTAssertEqual(failedStats.activeRowCount, 260)+ let hits = try await maintained.query(.history, text: "permission harb", limit: 300)+ XCTAssertEqual(Set(hits.map(\.id)), Set(records.map(\.id)))+ try FileManager.default.setAttributes([.posixPermissions: 0o700], ofItemAtPath: namespace.path)+ let retry = try await maintained.reconcile(.history, with: records)+ let retriedStats = try await store.stats()+ XCTAssertEqual(retry, .init(upserted: 0, deleted: 0))+ XCTAssertEqual(retriedStats.activeRowCount, 0)+ let restoredHits = try await maintained.query(.history, text: "permission harb", limit: 300)+ XCTAssertEqual(Set(restoredHits.map(\.id)), Set(records.map(\.id)))+ } catch {+ try? FileManager.default.setAttributes([.posixPermissions: 0o700], ofItemAtPath: namespace.path)+ await database.closeAll()+ throw error+ }+ await database.closeAll()+ }+/// A damaged namespace is moved aside by `FluidZeppelinRoot`; the next reconcile/// then refills the empty one. Nothing is lost because the store still has it.func testAResetNamespaceIsRefilledByTheNextReconcile() async throws {@@ -315,7 +519,7 @@ final class SearchIndexCoordinatorTests: XCTestCase {XCTAssertEqual(afterEdits, [saved.id, deleted.id, stale.id], "Edits after a failed load are still an incomplete snapshot")try fixture.defaults.set(JSONEncoder().encode([saved, deleted]), forKey: "TranscriptionHistoryEntries")- history.retryPersistence()+ history.retryLoadingIfNeeded()try await history.waitUntilLoaded()XCTAssertNil(history.persistenceError)XCTAssertEqual(Set(history.entries.map(\.id)), [saved.id, pending.id])@@ -339,6 +543,30 @@ final class SearchIndexCoordinatorTests: XCTestCase {}}+ func testSearchRetryNeverRewritesSuccessfullyLoadedHistory() async throws {+ try await self.withFixture { fixture in+ let saved = self.entry("saved history must remain untouched")+ try fixture.defaults.set(JSONEncoder().encode([saved]), forKey: "TranscriptionHistoryEntries")+ let history = TranscriptionHistoryStore(writer: fixture.writer)+ try await history.waitUntilLoaded()+ var connection: OpaquePointer?+ XCTAssertEqual(sqlite3_open(fixture.historyURL.path, &connection), SQLITE_OK)+ let database = try XCTUnwrap(connection)+ defer { sqlite3_close(database) }+ // retryPersistence's loaded branch deletes every row before rewriting.+ // Make that unintended operation fail instead of merely comparing IDs.+ XCTAssertEqual(sqlite3_exec(database, "CREATE TRIGGER reject_history_rewrite BEFORE DELETE ON history BEGIN SELECT RAISE(ABORT, 'unexpected history rewrite'); END", nil, nil, nil), SQLITE_OK)+ history.retryLoadingIfNeeded()+ await history.finishPendingWrites()+ XCTAssertNil(history.persistenceError)+ let writeError = await fixture.writer.drain()+ XCTAssertNil(writeError)+ let rows = try await fixture.writer.load()+ XCTAssertEqual(rows.map(\.id), [saved.id])+ XCTAssertEqual(history.entries.map(\.id), [saved.id])+ }+ }+func testClearingLoadedHistoryDeletesIndexedRecords() async throws {try await self.withFixture { fixture inlet saved = self.entry("startup saved dictation")@@ -412,4 +640,731 @@ final class SearchIndexCoordinatorTests: XCTestCase {try await self.waitForIndexedIDs([saved.id], in: fixture.index)}}++ func testFirstSearchPreparationWaitsForLoadedHistoryAndSuppressesSelfRefresh() async throws {+ try await self.withFixture { fixture in+ let saved = self.entry("first query authoritative history")+ try fixture.defaults.set(JSONEncoder().encode([saved]), forKey: "TranscriptionHistoryEntries")+ let history = TranscriptionHistoryStore(writer: fixture.writer)+ try await history.waitUntilLoaded()+ let probe = SearchReconcileProbe(gatedCallCount: 3)+ var refreshCount = 0+ let coordinator = SearchIndexCoordinator(+ index: fixture.index,+ reconcile: { kind, records in try await probe.reconcile(kind, records: records) },+ refresh: { refreshCount += 1 }+ )+ var prepared = false+ let preparation = Task { try await coordinator.prepareForSearch(historyStore: history); prepared = true }+ do {+ let deadline = ContinuousClock.now.advanced(by: .seconds(5))+ while await probe.calls().count < 3, ContinuousClock.now < deadline {+ try await Task.sleep(for: .milliseconds(10))+ }+ let calls = await probe.calls()+ XCTAssertEqual(calls.count, 3)+ guard calls.count == 3 else { throw SearchReconcileProbe.Failure.unavailable }+ let indexedHistory = try XCTUnwrap(calls.first { $0.kind == .history })+ XCTAssertEqual(indexedHistory.records.map(\.id), [saved.id])+ XCTAssertEqual(indexedHistory.records.first?.text, saved.searchRecord.text)+ XCTAssertFalse(prepared, "The first query cannot run against an unfinished history snapshot")+ XCTAssertEqual(refreshCount, 0)+ await probe.releaseAll()+ let completionDeadline = ContinuousClock.now.advanced(by: .seconds(5))+ while !prepared, ContinuousClock.now < completionDeadline {+ try await Task.sleep(for: .milliseconds(10))+ }+ XCTAssertTrue(prepared)+ guard prepared else { throw SearchReconcileProbe.Failure.unavailable }+ try await preparation.value+ XCTAssertEqual(refreshCount, 0, "Seeding the first search must not cancel and restart its own query")+ } catch {+ await probe.releaseAll()+ await coordinator.stop()+ _ = await preparation.result+ throw error+ }+ await coordinator.stop()+ }+ }+}++private struct SearchBenchmarkRecord: Decodable {+ let id: UUID+ let revision: UInt64+ let timestampMilliseconds: Int64+ let text: String++ var record: SearchIndexRecord {+ SearchIndexRecord(id: self.id, revision: self.revision, timestamp: Date(timeIntervalSince1970: Double(self.timestampMilliseconds) / 1000), text: self.text)+ }+}++private actor SearchReconcileProbe {+ struct Call: Sendable {+ let kind: SearchIndexKind+ let records: [SearchIndexRecord]+ }++ enum Failure: Error { case unavailable }++ private var recorded: [Call] = []+ private var gates: [Int: CheckedContinuation<Void, Never>] = [:]+ private var released = false+ private var active: [SearchIndexKind: Int] = [:]+ private var peak: [SearchIndexKind: Int] = [:]+ private let gatedCallCount: Int+ private let failingCalls: Set<Int>++ init(gatedCallCount: Int = 2, failingCalls: Set<Int> = []) {+ self.gatedCallCount = gatedCallCount+ self.failingCalls = failingCalls+ }++ func reconcile(_ kind: SearchIndexKind, records: [SearchIndexRecord]) async throws -> SearchIndex.ReconcileReport {+ let number = self.recorded.count+ self.recorded.append(Call(kind: kind, records: records))+ self.active[kind, default: 0] += 1+ self.peak[kind] = max(self.peak[kind, default: 0], self.active[kind, default: 0])+ defer { self.active[kind, default: 0] -= 1 }+ if !self.released, number < self.gatedCallCount {+ await withCheckedContinuation { self.gates[number] = $0 }+ }+ if self.failingCalls.contains(number) { throw Failure.unavailable }+ return .init(upserted: records.count, deleted: 0)+ }++ func calls() -> [Call] { self.recorded }+ func maximumConcurrentCalls(_ kind: SearchIndexKind) -> Int { self.peak[kind, default: 0] }+ func release(_ number: Int) { self.gates.removeValue(forKey: number)?.resume() }++ func releaseAll() {+ self.released = true+ let gates = self.gates.values+ self.gates.removeAll()+ for gate in gates {+ gate.resume()+ }+ }+}++@MainActor+final class SearchIndexCoordinatorSchedulingTests: XCTestCase {+ private func entry(_ text: String) -> TranscriptionHistoryEntry {+ TranscriptionHistoryEntry(rawText: text, processedText: text, appName: "Fixture", windowTitle: "Fixture", wasAIProcessed: false)+ }++ private func withProbe(failingCalls: Set<Int> = [], preparationTimeout: Duration = .seconds(20), _ body: (SearchIndexCoordinator, SearchReconcileProbe, () -> Int) async throws -> Void) async throws {+ let probe = SearchReconcileProbe(failingCalls: failingCalls)+ var refreshCount = 0+ let coordinator = SearchIndexCoordinator(+ reconcile: { kind, records in+ try await probe.reconcile(kind, records: records)+ },+ refresh: { refreshCount += 1 },+ preparationTimeout: preparationTimeout+ )+ do {+ try await body(coordinator, probe) { refreshCount }+ } catch {+ await probe.releaseAll()+ await coordinator.stop()+ throw error+ }+ await probe.releaseAll()+ await coordinator.stop()+ }++ private func waitForCalls(_ count: Int, in probe: SearchReconcileProbe) async throws {+ try await self.waitUntil { await probe.calls().count >= count }+ }++ private func waitUntil(_ condition: () async -> Bool) async throws {+ let deadline = ContinuousClock.now.advanced(by: .seconds(5))+ while !(await condition()), ContinuousClock.now < deadline {+ try await Task.sleep(for: .milliseconds(10))+ }+ guard await condition() else {+ XCTFail("A bounded search scheduling condition did not complete")+ throw SearchReconcileProbe.Failure.unavailable+ }+ }++ func testRapidSnapshotsKeepOneWorkerAndOnlyTheLatestSuccessor() async throws {+ try await self.withProbe { coordinator, probe, refreshCount in+ let first = self.entry("first snapshot")+ coordinator.submit(.history([first]))+ coordinator.flush()+ try await self.waitForCalls(1, in: probe)+ var latest = first+ for number in 0..<100 {+ latest = self.entry("latest snapshot \(number)")+ coordinator.submit(.history([latest]))+ coordinator.flush()+ }+ let before = await probe.calls()+ XCTAssertEqual(before.count, 1, "A blocked reconcile must not spawn a task chain")+ var completed = false+ var captureStarted = false+ let barrier = Task { captureStarted = true; try await coordinator.waitUntilCurrent(); completed = true }+ try await self.waitUntil { captureStarted }+ await probe.release(0)+ try await self.waitForCalls(2, in: probe)+ XCTAssertFalse(completed, "The current snapshot barrier must include the captured latest snapshot")+ XCTAssertEqual(refreshCount(), 0, "Do not refresh results from an intermediate snapshot")+ let calls = await probe.calls()+ XCTAssertEqual(calls.map { $0.records.map(\.id) }, [[first.id], [latest.id]])+ XCTAssertEqual(calls[1].records.first?.text, latest.searchRecord.text)+ await probe.release(1)+ try await self.waitUntil { completed }+ try await barrier.value+ try await self.waitUntil { refreshCount() == 1 }+ let peak = await probe.maximumConcurrentCalls(.history)+ XCTAssertEqual(peak, 1)+ }+ }++ func testCapturedBarrierIsNotExtendedByLaterSnapshots() async throws {+ try await self.withProbe { coordinator, probe, _ in+ coordinator.submit(.history([self.entry("captured snapshot")]))+ coordinator.flush()+ try await self.waitForCalls(1, in: probe)+ var completed = false+ var captureStarted = false+ let barrier = Task { captureStarted = true; try await coordinator.waitUntilCurrent(); completed = true }+ // Let the barrier capture generation one before sending generation two.+ try await self.waitUntil { captureStarted }+ coordinator.submit(.history([self.entry("later snapshot")]))+ await probe.release(0)+ try await self.waitForCalls(2, in: probe)+ try await self.waitUntil { completed }+ try await barrier.value+ await probe.release(1)+ try await coordinator.waitUntilCurrent()+ }+ }++ func testStopDropsQueuedSnapshotsCancelsWaitersAndDrainsCurrentWork() async throws {+ try await self.withProbe { coordinator, probe, refreshCount in+ coordinator.submit(.history([self.entry("running snapshot")]))+ coordinator.flush()+ try await self.waitForCalls(1, in: probe)+ coordinator.submit(.history([self.entry("queued snapshot")]))+ var barrierCancelled = false+ let barrier = Task {+ do {+ try await coordinator.waitUntilCurrent()+ XCTFail("Stop must cancel the barrier")+ } catch is CancellationError {+ barrierCancelled = true+ } catch {+ XCTFail("Unexpected barrier failure: \(error)")+ }+ }+ await Task.yield()+ var stopped = false+ let stop = Task { await coordinator.stop(); stopped = true }+ try await self.waitUntil { barrierCancelled }+ XCTAssertFalse(stopped, "Stop must await the actual in-flight write before closeAll")+ await probe.release(0)+ try await self.waitUntil { stopped }+ await stop.value+ await barrier.value+ coordinator.submit(.history([self.entry("after stop")]))+ coordinator.flush()+ do {+ try await coordinator.waitUntilCurrent()+ XCTFail("A stopped coordinator cannot reopen")+ } catch is CancellationError {}+ let calls = await probe.calls()+ XCTAssertEqual(calls.count, 1)+ XCTAssertEqual(refreshCount(), 0, "Late work must not refresh search during termination")+ }+ }++ func testFailedReconcileFinishesBarrierAndExplicitRetryUsesLatestSnapshot() async throws {+ try await self.withProbe(failingCalls: [0]) { coordinator, probe, refreshCount in+ coordinator.submit(.history([self.entry("failed first snapshot")]))+ coordinator.flush()+ try await self.waitForCalls(1, in: probe)+ let latest = self.entry("latest retry snapshot")+ coordinator.submit(.history([latest]))+ var failed = false+ let barrier = Task {+ do {+ try await coordinator.waitUntilCurrent()+ XCTFail("The first reconcile is intentionally unavailable")+ } catch SearchReconcileProbe.Failure.unavailable {+ failed = true+ }+ }+ await Task.yield()+ await probe.release(0)+ try await self.waitUntil { failed }+ try await barrier.value+ XCTAssertEqual(refreshCount(), 0)+ var retried = false+ let retry = Task { try await coordinator.waitUntilCurrent(); retried = true }+ try await self.waitForCalls(2, in: probe)+ let calls = await probe.calls()+ XCTAssertEqual(calls[1].records.map(\.id), [latest.id], "Retry cannot replay an older snapshot over newer input")+ await probe.release(1)+ try await self.waitUntil { retried }+ try await retry.value+ try await self.waitUntil { refreshCount() == 1 }+ }+ }++ func testPreparationTimeoutFinishesPromptlyWithoutStartingAnotherWorker() async throws {+ try await self.withProbe(preparationTimeout: .milliseconds(50)) { coordinator, probe, _ in+ coordinator.submit(.history([self.entry("temporarily slow snapshot")]))+ coordinator.flush()+ try await self.waitForCalls(1, in: probe)+ let start = ContinuousClock.now+ do {+ try await coordinator.waitUntilCurrent()+ XCTFail("The blocked writer must exceed the injected preparation deadline")+ } catch SearchIndexCoordinator.PreparationError.timedOut {}+ XCTAssertLessThan(start.duration(to: .now), .seconds(2))+ let before = await probe.calls()+ XCTAssertEqual(before.count, 1, "Timeout must not create another index worker")+ await probe.release(0)+ try await coordinator.waitUntilCurrent()+ let peak = await probe.maximumConcurrentCalls(.history)+ XCTAssertEqual(peak, 1)+ }+ }++ func testCancellingOneBarrierDoesNotCancelTheSharedIndexWorkerOrOtherWaiter() async throws {+ try await self.withProbe { coordinator, probe, _ in+ coordinator.submit(.history([self.entry("shared pending snapshot")]))+ coordinator.flush()+ try await self.waitForCalls(1, in: probe)+ var cancelled = false+ var survivorCompleted = false+ let first = Task {+ do {+ try await coordinator.waitUntilCurrent()+ XCTFail("This waiter was cancelled")+ } catch is CancellationError {+ cancelled = true+ }+ }+ let survivor = Task { try await coordinator.waitUntilCurrent(); survivorCompleted = true }+ first.cancel()+ try await self.waitUntil { cancelled }+ try await first.value+ XCTAssertFalse(survivorCompleted)+ await probe.release(0)+ try await self.waitUntil { survivorCompleted }+ try await survivor.value+ let calls = await probe.calls()+ XCTAssertEqual(calls.count, 1)+ }+ }+}++private struct SearchBenchmarkStats: Codable {+ let activeRows: UInt64+ let residentOwnedBytes: UInt64+ let mappedBytes: UInt64+ let segmentBytes: UInt64+ let walBytes: UInt64+ let physicalFootprint: UInt64?++ init(_ stats: StoreStats) {+ self.activeRows = stats.activeRowCount+ self.residentOwnedBytes = stats.residentOwnedBytes+ self.mappedBytes = stats.mappedBytes+ self.segmentBytes = stats.segmentBytes+ self.walBytes = stats.walBytes+ self.physicalFootprint = stats.physicalFootprint+ }+}++private struct SearchBenchmarkReopen: Codable {+ let queryMilliseconds: Double+ let reconcileMilliseconds: Double+ let returnedHits: Int+ let beforeQueryPhysicalFootprintBytes: UInt64?+ let afterQueryPhysicalFootprintBytes: UInt64?+ let afterReconcilePhysicalFootprintBytes: UInt64?+ let stats: SearchBenchmarkStats+}++private struct SearchBenchmarkVariant: Codable {+ let label: String+ let recordCount: Int+ let openMilliseconds: Double+ let reconcileMilliseconds: Double+ let initialUpserts: Int+ let initialDeletes: Int+ let beforeOpenPhysicalFootprintBytes: UInt64?+ let afterOpenPhysicalFootprintBytes: UInt64?+ let afterReconcilePhysicalFootprintBytes: UInt64?+ let before: SearchBenchmarkStats+ let after: SearchBenchmarkStats+ let membershipSHA256: String+ let queryMembershipSHA256: [String: String]+ let reopens: [SearchBenchmarkReopen]+}++extension SearchIndexTests {+ /// Exercises the real coordinator's snapshot construction and index updates,+ /// using synthetic finished dictations only. No audio, preferences or real stores.+ @MainActor+ func testOptInSequentialDictationMemoryGrowth() async throws {+ guard let path = ProcessInfo.processInfo.environment["FLUIDVOICE_SEARCH_APPEND_MEMORY_REPORT"], !path.isEmpty else {+ throw XCTSkip("Supply an external JSON report path for the incremental memory simulation")+ }+ let database = FluidZeppelinRoot(root: self.root.appendingPathComponent("append-memory", isDirectory: true))+ let index = SearchIndex(root: database)+ let coordinator = SearchIndexCoordinator(index: index, refresh: {}, preparationTimeout: .seconds(120))+ var entries = (0..<12_880).map { number in+ TranscriptionHistoryEntry(+ rawText: "not indexed",+ processedText: "seedhistory item\(number) " + String(repeating: "meeting project update planning notes ", count: 5),+ appName: "Synthetic fixture",+ windowTitle: "Search memory simulation",+ wasAIProcessed: false+ )+ }+ var samples: [SearchAppendMemorySample] = []+ var timings: [Double] = []+ var peak: UInt64 = 0+ var samplerTicks = 0+ var sampler: Task<Void, Never>?+ do {+ coordinator.submit(.history(entries))+ try await coordinator.waitUntilCurrent()+ _ = try await index.query(.history, text: "seedhistory", limit: 50)+ let store = try await index.namespace(.history)+ try samples.append(await self.appendMemorySample("prepared baseline", added: 0, sourceRows: entries.count, store: store))+ peak = Self.physicalFootprint() ?? 0+ sampler = Task {+ // Bound diagnostic storage/work even if native recovery is slow.+ while !Task.isCancelled, samplerTicks < 20_000 {+ peak = max(peak, Self.physicalFootprint() ?? 0)+ samplerTicks += 1+ do { try await Task.sleep(for: .milliseconds(10)) } catch { return }+ }+ }+ for added in 1...1024 {+ entries.append(TranscriptionHistoryEntry(+ rawText: "not indexed",+ processedText: "appendmarker update\(added) " + String(repeating: "finished dictation project followup ", count: added % 8 + 1),+ appName: "Synthetic fixture",+ windowTitle: "Sequential additions",+ wasAIProcessed: false+ ))+ let started = ContinuousClock.now+ coordinator.submit(.history(entries))+ try await coordinator.waitUntilCurrent()+ timings.append(Self.milliseconds(since: started))+ if added % 32 == 0 || added == 1 || added == 255 || added == 257 {+ let hits = try await index.query(.history, text: "appendmarker update\(added)", limit: 50)+ XCTAssertTrue(hits.contains { $0.id == entries.last?.id })+ try samples.append(await self.appendMemorySample("sequential", added: added, sourceRows: entries.count, store: store))+ }+ if added % 256 == 0 {+ let stats = try await store.stats()+ XCTAssertEqual(stats.activeRowCount, 0)+ print("Search append simulation: \(added) additions indexed and sealed")+ }+ }+ // A rapid event burst must keep only the latest successor snapshot.+ for added in 1025...1280 {+ entries.append(TranscriptionHistoryEntry(+ rawText: "not indexed",+ processedText: "burstmarker update\(added) " + String(repeating: "rapid finished history update ", count: 6),+ appName: "Synthetic fixture",+ windowTitle: "Burst additions",+ wasAIProcessed: false+ ))+ coordinator.submit(.history(entries))+ }+ try await coordinator.waitUntilCurrent()+ try samples.append(await self.appendMemorySample("burst drained", added: 1280, sourceRows: entries.count, store: store))+ let burstStats = try await store.stats()+ XCTAssertEqual(burstStats.activeRowCount, 0)+ // More words require more memory even with the same row-count limit.+ for added in 1281...1408 {+ entries.append(TranscriptionHistoryEntry(+ rawText: "not indexed",+ processedText: "longmarker update\(added) " + String(repeating: "longer dictation contains discussion of project details and followup actions ", count: 220),+ appName: "Synthetic fixture",+ windowTitle: "Long additions",+ wasAIProcessed: false+ ))+ coordinator.submit(.history(entries))+ try await coordinator.waitUntilCurrent()+ if added % 32 == 0 {+ try samples.append(await self.appendMemorySample("long entries", added: added, sourceRows: entries.count, store: store))+ }+ }+ try await Task.sleep(for: .milliseconds(300))+ try samples.append(await self.appendMemorySample("settled", added: 1408, sourceRows: entries.count, store: store))+ var actual = Set<UUID>()+ for try await row in store.documents(fields: []) {+ actual.insert(row.id.uuid)+ }+ XCTAssertEqual(actual, Set(entries.map(\.id)))+ let latest = try await index.query(.history, text: "longmarker update1408", limit: 50)+ XCTAssertTrue(latest.contains { $0.id == entries.last?.id })+ sampler?.cancel()+ await sampler?.value+ await coordinator.stop()+ await database.closeAll()+ let closed = Self.physicalFootprint()+ let reopenedRoot = FluidZeppelinRoot(root: self.root.appendingPathComponent("append-memory", isDirectory: true))+ let reopened = SearchIndex(root: reopenedRoot)+ let reopenStart = ContinuousClock.now+ let reopenedHits = try await reopened.query(.history, text: "longmarker update1408", limit: 50)+ let reopenMilliseconds = Self.milliseconds(since: reopenStart)+ XCTAssertTrue(reopenedHits.contains { $0.id == entries.last?.id })+ let reopenedStore = try await reopened.namespace(.history)+ try samples.append(await self.appendMemorySample("reopened", added: 1408, sourceRows: entries.count, store: reopenedStore))+ await reopenedRoot.closeAll()+ let sorted = timings.sorted()+ let report = SearchAppendMemoryReport(+ initialRows: 12_880,+ addedRows: 1408,+ peakPhysicalFootprintBytes: peak,+ closedPhysicalFootprintBytes: closed,+ samplerTicks: samplerTicks,+ medianUpdateMilliseconds: sorted[sorted.count / 2],+ p95UpdateMilliseconds: sorted[Int(Double(sorted.count - 1) * 0.95)],+ reopenMilliseconds: reopenMilliseconds,+ samples: samples+ )+ let output = URL(fileURLWithPath: path)+ try FileManager.default.createDirectory(at: output.deletingLastPathComponent(), withIntermediateDirectories: true)+ let encoder = JSONEncoder()+ encoder.outputFormatting = [.prettyPrinted, .sortedKeys]+ try encoder.encode(report).write(to: output, options: .withoutOverwriting)+ print("Search append memory report: \(output.path)")+ } catch {+ sampler?.cancel()+ await sampler?.value+ await coordinator.stop()+ await database.closeAll()+ throw error+ }+ }++ private func appendMemorySample(_ phase: String, added: Int, sourceRows: Int, store: ZeppelinStore) async throws -> SearchAppendMemorySample {+ let stats = try await store.stats()+ return SearchAppendMemorySample(+ phase: phase,+ addedRows: added,+ sourceRows: sourceRows,+ processPhysicalFootprintBytes: Self.physicalFootprint(),+ index: SearchBenchmarkStats(stats),+ cacheBytes: stats.cacheBytes,+ queryPoolBytes: stats.queryPoolBytes,+ openFiles: stats.openFiles+ )+ }++ /// Explicitly supplied JSON is an exported private copy, never a production+ /// store. Both variants modify only unique test roots. Reports omit all text.+ func testOptInCopiedRealHistoryReopenBenchmark() async throws {+ let environment = ProcessInfo.processInfo.environment+ guard let recordsPath = environment["FLUIDVOICE_SEARCH_BENCHMARK_RECORDS"],+ let outputPath = environment["FLUIDVOICE_SEARCH_BENCHMARK_OUTPUT"]+ else { throw XCTSkip("Supply private record JSON and a report directory to run the search reopen benchmark") }+ let input = URL(fileURLWithPath: recordsPath)+ let attributes = try FileManager.default.attributesOfItem(atPath: input.path)+ XCTAssertLessThanOrEqual((attributes[.size] as? NSNumber)?.intValue ?? Int.max, 256 * 1024 * 1024)+ guard (attributes[.size] as? NSNumber)?.intValue ?? Int.max <= 256 * 1024 * 1024 else {+ throw CocoaError(.fileReadTooLarge)+ }+ let records = try JSONDecoder().decode([SearchBenchmarkRecord].self, from: Data(contentsOf: input)).map(\.record)+ XCTAssertTrue((10_000...20_000).contains(records.count), "Use the real approximately 13k-record corpus")+ let expectedIDs = Set(records.map(\.id))+ XCTAssertEqual(expectedIDs.count, records.count)+ guard (10_000...20_000).contains(records.count), expectedIDs.count == records.count else {+ throw CocoaError(.coderInvalidValue)+ }+ let queries = ["the", "meeting", "mo", "project", "update"]+ let labels: [String]+ if let variant = environment["FLUIDVOICE_SEARCH_BENCHMARK_VARIANT"] {+ guard ["baseline", "optimized"].contains(variant) else { throw CocoaError(.coderInvalidValue) }+ labels = [variant]+ } else {+ labels = ["baseline", "optimized"]+ }+ var variants: [SearchBenchmarkVariant] = []+ try FileManager.default.createDirectory(at: self.root, withIntermediateDirectories: true)+ for label in labels {+ let directory = self.root.appendingPathComponent(label, isDirectory: true)+ if let sourcePath = environment["FLUIDVOICE_SEARCH_BENCHMARK_SOURCE_INDEX"] {+ // Optional frozen index copy permits unchanged legacy-backfill+ // timing. The provided source directory is never opened/written.+ try FileManager.default.copyItem(at: URL(fileURLWithPath: sourcePath, isDirectory: true), to: directory)+ }+ let result = try await self.benchmarkVariant(label, directory: directory, records: records, queries: queries)+ XCTAssertEqual(result.membershipSHA256, Self.membershipHash(expectedIDs))+ if label == "optimized" { XCTAssertEqual(result.after.activeRows, 0) }+ if let baseline = variants.first {+ XCTAssertEqual(result.queryMembershipSHA256, baseline.queryMembershipSHA256, "Sealing must preserve all matching IDs; top-50 score ties may legitimately reorder")+ XCTAssertEqual(result.initialUpserts, baseline.initialUpserts)+ XCTAssertEqual(result.initialDeletes, baseline.initialDeletes)+ }+ variants.append(result)+ if label == "optimized", let preparedPath = environment["FLUIDVOICE_SEARCH_BENCHMARK_EXPORT_PREPARED_INDEX"] {+ // An explicitly requested private fixture for a fresh-process+ // reopen measurement; never exported by ordinary test runs.+ let destination = URL(fileURLWithPath: preparedPath, isDirectory: true)+ try FileManager.default.createDirectory(at: destination.deletingLastPathComponent(), withIntermediateDirectories: true, attributes: [.posixPermissions: 0o700])+ try FileManager.default.copyItem(at: directory, to: destination)+ try FileManager.default.setAttributes([.posixPermissions: 0o700], ofItemAtPath: destination.path)+ }+ }+ let output = URL(fileURLWithPath: outputPath, isDirectory: true)+ try FileManager.default.createDirectory(at: output, withIntermediateDirectories: true)+ let encoder = JSONEncoder()+ encoder.outputFormatting = [.prettyPrinted, .sortedKeys]+ let report = output.appendingPathComponent("search-index-benchmark-\(UUID().uuidString).json")+ try encoder.encode(variants).write(to: report, options: .withoutOverwriting)+ print("Search index benchmark report: \(report.path)")+ }++ private func benchmarkVariant(_ label: String, directory: URL, records: [SearchIndexRecord], queries: [String]) async throws -> SearchBenchmarkVariant {+ let root = FluidZeppelinRoot(root: directory)+ let index = SearchIndex(root: root, maintenanceActiveRowLimit: label == "baseline" ? nil : 256)+ let beforeOpenFootprint = Self.physicalFootprint()+ let start = ContinuousClock.now+ let store: ZeppelinStore+ let before: StoreStats+ let report: SearchIndex.ReconcileReport+ let openMilliseconds: Double+ let afterOpenFootprint: UInt64?+ let reconcileMilliseconds: Double+ let afterReconcileFootprint: UInt64?+ let after: StoreStats+ var membership = Set<UUID>()+ var queryHashes: [String: String] = [:]+ do {+ store = try await index.namespace(.history)+ openMilliseconds = Self.milliseconds(since: start)+ afterOpenFootprint = Self.physicalFootprint()+ before = try await store.stats()+ let reconcileStart = ContinuousClock.now+ report = try await index.reconcile(.history, with: records)+ reconcileMilliseconds = Self.milliseconds(since: reconcileStart)+ afterReconcileFootprint = Self.physicalFootprint()+ after = try await store.stats()+ for try await document in store.documents(fields: []) {+ membership.insert(document.id.uuid)+ }+ // Full membership avoids mistaking a different ordering of equal+ // BM25 scores at the result limit for a lost document.+ for query in queries {+ let hits = try await index.query(.history, text: query, limit: records.count)+ queryHashes[query] = Self.membershipHash(Set(hits.map(\.id)))+ }+ } catch {+ await root.closeAll()+ throw error+ }+ await root.closeAll()+ var reopens: [SearchBenchmarkReopen] = []+ for iteration in 0..<5 {+ let freshRoot = FluidZeppelinRoot(root: directory)+ let fresh = SearchIndex(root: freshRoot, maintenanceActiveRowLimit: label == "baseline" ? nil : 256)+ do {+ let beforeQueryFootprint = Self.physicalFootprint()+ let queryStart = ContinuousClock.now+ // This first query opens the namespace; no cached actor/handle+ // from a prior iteration can hide startup WAL replay.+ let hits = try await fresh.query(.history, text: queries[iteration % queries.count], limit: 50)+ let queryMilliseconds = Self.milliseconds(since: queryStart)+ let afterQueryFootprint = Self.physicalFootprint()+ let reconcileStart = ContinuousClock.now+ let unchanged = try await fresh.reconcile(.history, with: records)+ let reconcileMilliseconds = Self.milliseconds(since: reconcileStart)+ let afterReconcileFootprint = Self.physicalFootprint()+ XCTAssertEqual(unchanged, .init(upserted: 0, deleted: 0))+ let freshStore = try await fresh.namespace(.history)+ let stats = try await freshStore.stats()+ let count = try await freshStore.count().count+ XCTAssertEqual(count, UInt64(records.count))+ reopens.append(SearchBenchmarkReopen(+ queryMilliseconds: queryMilliseconds,+ reconcileMilliseconds: reconcileMilliseconds,+ returnedHits: hits.count,+ beforeQueryPhysicalFootprintBytes: beforeQueryFootprint,+ afterQueryPhysicalFootprintBytes: afterQueryFootprint,+ afterReconcilePhysicalFootprintBytes: afterReconcileFootprint,+ stats: SearchBenchmarkStats(stats)+ ))+ } catch {+ await freshRoot.closeAll()+ throw error+ }+ await freshRoot.closeAll()+ }+ return SearchBenchmarkVariant(+ label: label,+ recordCount: records.count,+ openMilliseconds: openMilliseconds,+ reconcileMilliseconds: reconcileMilliseconds,+ initialUpserts: report.upserted,+ initialDeletes: report.deleted,+ beforeOpenPhysicalFootprintBytes: beforeOpenFootprint,+ afterOpenPhysicalFootprintBytes: afterOpenFootprint,+ afterReconcilePhysicalFootprintBytes: afterReconcileFootprint,+ before: SearchBenchmarkStats(before),+ after: SearchBenchmarkStats(after),+ membershipSHA256: Self.membershipHash(membership),+ queryMembershipSHA256: queryHashes,+ reopens: reopens+ )+ }++ private static func membershipHash(_ ids: Set<UUID>) -> String {+ let input = ids.map(\.uuidString).sorted().joined(separator: "\n")+ return SHA256.hash(data: Data(input.utf8)).map { String(format: "%02x", $0) }.joined()+ }++ private static func milliseconds(since start: ContinuousClock.Instant) -> Double {+ let components = start.duration(to: .now).components+ return Double(components.seconds) * 1000 + Double(components.attoseconds) / 1_000_000_000_000_000+ }++ private static func physicalFootprint() -> UInt64? {+ var info = task_vm_info_data_t()+ var count = mach_msg_type_number_t(MemoryLayout<task_vm_info_data_t>.size / MemoryLayout<integer_t>.size)+ let capacity = Int(count)+ let result = withUnsafeMutablePointer(to: &info) { pointer in+ pointer.withMemoryRebound(to: integer_t.self, capacity: capacity) {+ task_info(mach_task_self_, task_flavor_t(TASK_VM_INFO), $0, &count)+ }+ }+ return result == KERN_SUCCESS ? info.phys_footprint : nil+ }+}++private struct SearchAppendMemorySample: Codable {+ let phase: String+ let addedRows: Int+ let sourceRows: Int+ let processPhysicalFootprintBytes: UInt64?+ let index: SearchBenchmarkStats+ let cacheBytes: UInt64+ let queryPoolBytes: UInt64+ let openFiles: UInt64+}++private struct SearchAppendMemoryReport: Codable {+ let initialRows: Int+ let addedRows: Int+ let peakPhysicalFootprintBytes: UInt64+ let closedPhysicalFootprintBytes: UInt64?+ let samplerTicks: Int+ let medianUpdateMilliseconds: Double+ let p95UpdateMilliseconds: Double+ let reopenMilliseconds: Double+ let samples: [SearchAppendMemorySample]}diff --git a/Tests/FluidDictationIntegrationTests/SettingsBackupRoundTripTests.swift b/Tests/FluidDictationIntegrationTests/SettingsBackupRoundTripTests.swiftnew file mode 100644index 00000000..72c0e9e7--- /dev/null+++ b/Tests/FluidDictationIntegrationTests/SettingsBackupRoundTripTests.swift@@ -0,0 +1,157 @@+import AppKit+@testable import FluidVoice_Debug+import XCTest++@MainActor+final class SettingsBackupRoundTripTests: XCTestCase {+ func testModernBackupExportsAndRestoresMeetingIdleAndPromptConfiguration() throws {+ try self.withSavedDefaults {+ let settings = SettingsStore.shared+ let profile = self.profile(id: "backup-dictation")+ let meeting = self.meetingDefaults()+ let configurations = self.configurations(profileID: profile.id)+ settings.dictationPromptProfiles = [profile]+ settings.meetingRecordingDefaults = meeting+ settings.privateAIIdleUnload = .oneHour+ settings.dictationPromptConfigurations = configurations+ let payload = settings.makeBackupPayload()+ let encoded = try JSONEncoder().encode(payload)+ let json = try XCTUnwrap(JSONSerialization.jsonObject(with: encoded) as? [String: Any])+ XCTAssertNotNil(json["meetingRecordingDefaults"])+ XCTAssertEqual(json["privateAIIdleUnload"] as? Int, 60)+ XCTAssertNotNil(json["dictationPromptConfigurations"])++ settings.meetingRecordingDefaults = .unconfigured+ settings.privateAIIdleUnload = .never+ settings.dictationPromptConfigurations = [:]+ settings.dictationPromptProfiles = []+ try settings.restore(+ from: JSONDecoder().decode(SettingsBackupPayload.self, from: encoded),+ promptProfiles: [profile],+ appPromptBindings: []+ )+ XCTAssertEqual(settings.meetingRecordingDefaults, meeting)+ XCTAssertEqual(settings.privateAIIdleUnload, .oneHour)+ XCTAssertEqual(settings.dictationPromptConfigurations, configurations)+ XCTAssertEqual(settings.dictationPromptShortcutAssignments().count, 3)+ XCTAssertEqual(settings.selectedProviderID, payload.selectedProviderID)+ XCTAssertEqual(settings.primaryDictationShortcuts, payload.primaryDictationShortcuts)+ }+ }++ func testLegacyAbsentFieldsPreserveCurrentPreferences() throws {+ try self.withSavedDefaults {+ let settings = SettingsStore.shared+ let profile = self.profile(id: "legacy-survivor")+ settings.dictationPromptProfiles = [profile]+ let payload = try self.payload(removing: [+ "meetingRecordingDefaults", "privateAIIdleUnload", "dictationPromptConfigurations",+ ])+ let meeting = self.meetingDefaults()+ let configurations = self.configurations(profileID: profile.id)+ settings.meetingRecordingDefaults = meeting+ settings.privateAIIdleUnload = .thirtyMinutes+ settings.dictationPromptConfigurations = configurations+ settings.restore(from: payload, promptProfiles: [profile], appPromptBindings: [])+ XCTAssertEqual(settings.meetingRecordingDefaults, meeting)+ XCTAssertEqual(settings.privateAIIdleUnload, .thirtyMinutes)+ XCTAssertEqual(settings.dictationPromptConfigurations, configurations)+ }+ }++ func testExplicitEmptyPromptConfigurationsClearPreviousMappings() throws {+ try self.withSavedDefaults {+ let settings = SettingsStore.shared+ settings.dictationPromptConfigurations = [:]+ let payload = settings.makeBackupPayload()+ let json = try XCTUnwrap(JSONSerialization.jsonObject(with: JSONEncoder().encode(payload)) as? [String: Any])+ XCTAssertEqual((json["dictationPromptConfigurations"] as? [String: Any])?.count, 0)+ settings.dictationPromptConfigurations = self.configurations(profileID: "previous")+ settings.restore(from: payload, promptProfiles: [], appPromptBindings: [])+ XCTAssertTrue(settings.dictationPromptConfigurations.isEmpty)+ XCTAssertTrue(settings.dictationPromptShortcutAssignments().isEmpty)+ }+ }++ func testImportedPromptConfigurationsUseRestoredProfilesAndCannotActivateInvalidReferences() throws {+ try self.withSavedDefaults {+ let settings = SettingsStore.shared+ let valid = self.profile(id: "imported")+ let edit = self.profile(id: "edit-only", mode: .edit)+ let shortcut = HotkeyShortcut(keyCode: 2, modifierFlags: [.control, .option])+ let imported: [String: SettingsStore.DictationPromptConfiguration] = [+ "profile:imported": .init(shortcut: shortcut, providerID: "openai", modelName: "imported-model"),+ "profile:missing": .init(shortcut: shortcut, providerID: "openai", modelName: "missing-model"),+ "profile:edit-only": .init(shortcut: shortcut, providerID: "openai", modelName: "edit-model"),+ "unknown": .init(shortcut: shortcut),+ "__default__": .init(shortcut: HotkeyShortcut(keyCode: 2, modifierFlags: []), providerID: "openai", modelName: "default-model"),+ "__privateAI__": .init(shortcut: shortcut, providerID: "apple-intelligence", modelName: "retired-model"),+ ]+ var json = try XCTUnwrap(JSONSerialization.jsonObject(with: JSONEncoder().encode(settings.makeBackupPayload())) as? [String: Any])+ json["dictationPromptConfigurations"] = try JSONSerialization.jsonObject(with: JSONEncoder().encode(imported))+ let payload = try JSONDecoder().decode(SettingsBackupPayload.self, from: JSONSerialization.data(withJSONObject: json))+ settings.dictationPromptProfiles = [self.profile(id: "previous")]+ settings.dictationPromptConfigurations = ["profile:previous": .init(shortcut: shortcut)]+ settings.restore(from: payload, promptProfiles: [valid, edit], appPromptBindings: [])++ XCTAssertEqual(settings.dictationPromptConfigurations["profile:imported"], imported["profile:imported"])+ XCTAssertNil(settings.dictationPromptConfigurations["profile:missing"])+ XCTAssertNil(settings.dictationPromptConfigurations["profile:edit-only"])+ XCTAssertNil(settings.dictationPromptConfigurations["profile:previous"])+ XCTAssertNil(settings.dictationPromptConfigurations["unknown"])+ XCTAssertNil(settings.dictationPromptConfiguration(for: .default).shortcut)+ XCTAssertEqual(settings.dictationPromptConfiguration(for: .default).modelName, "default-model")+ XCTAssertEqual(settings.dictationPromptConfigurations["__privateAI__"], .init(shortcut: shortcut))+ XCTAssertEqual(settings.dictationPromptShortcutAssignments().count, 2)+ XCTAssertEqual(settings.selectedProviderID, payload.selectedProviderID)+ XCTAssertEqual(settings.primaryDictationShortcuts, payload.primaryDictationShortcuts)+ }+ }++ private func payload(removing keys: [String]) throws -> SettingsBackupPayload {+ var json = try XCTUnwrap(JSONSerialization.jsonObject(with: JSONEncoder().encode(SettingsStore.shared.makeBackupPayload())) as? [String: Any])+ for key in keys {+ json.removeValue(forKey: key)+ }+ return try JSONDecoder().decode(SettingsBackupPayload.self, from: JSONSerialization.data(withJSONObject: json))+ }++ private func profile(id: String, mode: SettingsStore.PromptMode = .dictate) -> SettingsStore.DictationPromptProfile {+ .init(id: id, name: "Backup fixture", prompt: "Keep these words", mode: mode)+ }++ private func configurations(profileID: String) -> [String: SettingsStore.DictationPromptConfiguration] {+ [+ "__default__": .init(shortcut: HotkeyShortcut(keyCode: 2, modifierFlags: .control), providerID: "openai", modelName: "default-model"),+ "__privateAI__": .init(shortcut: HotkeyShortcut(keyCode: 3, modifierFlags: .control), providerID: "fluid-fixture", modelName: "private-model"),+ "profile:\(profileID)": .init(shortcut: HotkeyShortcut(keyCode: 5, modifierFlags: .control), providerID: "custom:fixture", modelName: "profile-model"),+ ]+ }++ private func meetingDefaults() -> MeetingRecordingDefaults {+ .init(+ isConfigured: true,+ mode: .inRoom,+ applicationBundleIdentifier: "fixture.meeting",+ applicationDisplayName: "Fixture Meeting",+ microphoneCaptureDeviceID: "fixture-capture",+ microphoneCoreAudioUID: "fixture-core-audio",+ microphoneRole: .shared,+ languageCode: "fr"+ )+ }++ private func withSavedDefaults(_ body: () throws -> Void) throws {+ let defaults = UserDefaults.standard+ let domain = try XCTUnwrap(Bundle.main.bundleIdentifier)+ let original = defaults.persistentDomain(forName: domain)+ defer {+ if let original {+ defaults.setPersistentDomain(original, forName: domain)+ } else {+ defaults.removePersistentDomain(forName: domain)+ }+ }+ try body()+ }+}diff --git a/Tests/FluidDictationIntegrationTests/SpeechModelInstallationSnapshotTests.swift b/Tests/FluidDictationIntegrationTests/SpeechModelInstallationSnapshotTests.swiftnew file mode 100644index 00000000..2e0da1f6--- /dev/null+++ b/Tests/FluidDictationIntegrationTests/SpeechModelInstallationSnapshotTests.swift@@ -0,0 +1,539 @@+import CryptoKit+import Darwin+@testable import FluidVoice_Debug+import Foundation+import XCTest++@MainActor+private final class InstallationCapture {+ var modelID = "first"+}++private actor InstallationScanGate {+ private(set) var calls = 0+ private(set) var observedIDs: [[String]] = []+ private var continuations: [CheckedContinuation<Set<String>, Error>] = []++ func scan(_ probes: [SpeechModelInstallationSnapshot.Probe]) async throws -> Set<String> {+ self.calls += 1+ self.observedIDs.append(probes.map(\.modelID))+ return try await withCheckedThrowingContinuation { self.continuations.append($0) }+ }++ func complete(_ result: Result<Set<String>, Error>) {+ self.continuations.removeFirst().resume(with: result)+ }+}++private actor CompactCatalogFetchGate {+ private(set) var calls = 0+ private var waiting: [CheckedContinuation<Data, Error>] = []++ func fetch() async throws -> Data {+ self.calls += 1+ return try await withCheckedThrowingContinuation { self.waiting.append($0) }+ }++ func complete(_ result: Result<Data, Error>) {+ self.waiting.removeFirst().resume(with: result)+ }+}++private final nonisolated class CatalogTestClock: @unchecked Sendable {+ private let lock = NSLock()+ private var date = Date(timeIntervalSince1970: 1_000_000)++ func now() -> Date { self.lock.withLock { self.date } }+ func advance(_ seconds: TimeInterval) { self.lock.withLock { self.date.addTimeInterval(seconds) } }+}++@MainActor+final class SpeechModelInstallationSnapshotTests: XCTestCase {+ private func waitUntil(_ condition: @escaping @MainActor () async -> Bool) async throws {+ let deadline = Date().addingTimeInterval(2)+ while !(await condition()), Date() < deadline {+ try await Task.sleep(for: .milliseconds(1))+ }+ let completed = await condition()+ XCTAssertTrue(completed, "Snapshot operation must finish within the test deadline")+ }++ private struct FeedCase: Decodable {+ let file: String+ let lastSequence: Int+ let verdict: String+ }++ private struct PickCase: Decodable {+ let file: String+ let model: String+ let platform: String+ let build: Int+ let format: Int+ let release: String?+ }++ private var fixtures: URL {+ URL(fileURLWithPath: #filePath).deletingLastPathComponent().appendingPathComponent("Fixtures/ModelRelease")+ }++ private func fixture<T: Decodable>(_ type: T.Type, _ path: String) throws -> T {+ try JSONDecoder().decode(type, from: Data(contentsOf: self.fixtures.appendingPathComponent(path)))+ }++ private func fixtureKey() throws -> String {+ try XCTUnwrap(self.fixture([String: String].self, "test_key.json")["publicKey"])+ }++ private func releaseModels(release: String = "1.2.0", format: Int = 1, minBuild: Int = 27) -> [String: [String: [[String: Any]]]] {+ var result: [String: [String: [[String: Any]]]] = [:]+ for descriptor in [ParakeetSpeechModelCatalog.mini, ParakeetSpeechModelCatalog.pico] {+ result[descriptor.variant.rawValue] = ["macos": [[+ "release": release,+ "url": "https://models.fluidvoice.app/parakeet/fluid-\(descriptor.variant.rawValue)/\(release)/\(descriptor.folderName).tar",+ "sha256": String(repeating: descriptor.variant == .mini ? "a" : "b", count: 64),+ "manifestSHA256": String(repeating: descriptor.variant == .mini ? "c" : "d", count: 64),+ "bytes": descriptor.expectedDownloadBytes,+ "format": format,+ "minBuild": minBuild,+ ]]]+ }+ return result+ }++ private func signedFeed(+ key: Curve25519.Signing.PrivateKey,+ sequence: Int,+ models: [String: [String: [[String: Any]]]]+ ) throws -> Data {+ let payload = try JSONSerialization.data(withJSONObject: ["schema": 1, "sequence": sequence, "models": models])+ return try JSONSerialization.data(withJSONObject: [+ "payload": payload.base64EncodedString(), "signature": key.signature(for: payload).base64EncodedString(),+ ])+ }++ func testEveryCanonicalFeedFixtureGetsTheSameVerdict() throws {+ let key = try self.fixtureKey()+ let cases = try self.fixture([FeedCase].self, "feeds/expected.json")+ XCTAssertEqual(cases.count, 40)+ for feed in cases {+ let data = try Data(contentsOf: self.fixtures.appendingPathComponent("feeds/\(feed.file)"))+ let verdict: String+ do {+ _ = try SpeechModelFeed.verified(envelope: data, publicKeys: [key], lastSequence: feed.lastSequence)+ verdict = "ok"+ } catch {+ verdict = (error as? SpeechModelFeed.Rejection)?.rawValue ?? String(describing: error)+ }+ XCTAssertEqual(verdict, feed.verdict, feed.file)+ }+ }++ func testCanonicalReleasePicksAndProductionKeysMatchIPhone() throws {+ let key = try self.fixtureKey()+ let picks = try self.fixture([PickCase].self, "feeds/picks.json")+ XCTAssertEqual(picks.count, 7)+ for pick in picks {+ let data = try Data(contentsOf: self.fixtures.appendingPathComponent("feeds/\(pick.file)"))+ let payload = try SpeechModelFeed.verified(envelope: data, publicKeys: [key], lastSequence: 0)+ XCTAssertEqual(SpeechModelFeed.entry(in: payload, model: pick.model, platform: pick.platform, build: pick.build, supportedFormat: pick.format)?.release, pick.release)+ }+ let keys = try self.fixture([String: String].self, "public_keys.json")+ XCTAssertEqual(CompactSpeechModelReleaseCatalog.publicKeys, try [XCTUnwrap(keys["main"]), XCTUnwrap(keys["spare"])])+ let data = try Data(contentsOf: self.fixtures.appendingPathComponent("feeds/good.json"))+ XCTAssertThrowsError(try SpeechModelFeed.verified(envelope: data, publicKeys: CompactSpeechModelReleaseCatalog.publicKeys, lastSequence: 0)) {+ XCTAssertEqual($0 as? SpeechModelFeed.Rejection, .badSignature)+ }+ XCTAssertEqual(CompactSpeechModelReleaseCatalog.manifestURL.absoluteString, "https://models.fluidvoice.app/feed/v1/speech-models.json")+ XCTAssertEqual(CompactSpeechModelReleaseCatalog.maximumManifestBytes, 64 * 1024)+ }++ func testMacReleaseChangesOnlyTrustedMetadataAndNeverPicksIOS() throws {+ let key = Curve25519.Signing.PrivateKey()+ let payload = try SpeechModelFeed.verified(+ envelope: self.signedFeed(key: key, sequence: 5, models: self.releaseModels()),+ publicKeys: [key.publicKey.rawRepresentation.base64EncodedString()],+ lastSequence: 0+ )+ let descriptors = CompactSpeechModelReleaseCatalog.descriptors(in: payload, build: 27)+ for original in [ParakeetSpeechModelCatalog.mini, ParakeetSpeechModelCatalog.pico] {+ let release = try XCTUnwrap(descriptors[original.variant])+ XCTAssertNotEqual(release.archiveSHA256, original.archiveSHA256)+ XCTAssertNotEqual(release.manifestSHA256, original.manifestSHA256)+ XCTAssertEqual(release.expectedDownloadBytes, original.expectedDownloadBytes)+ XCTAssertEqual(release.folderName, original.folderName)+ XCTAssertEqual(release.requiredModelNames, original.requiredModelNames)+ XCTAssertEqual(release.vocabularyFile, original.vocabularyFile)+ XCTAssertEqual(release.displayName, original.displayName)+ XCTAssertEqual(release.cardDescription, original.cardDescription)+ XCTAssertEqual(release.supportedLanguageCodes, ["en"])+ }+ let builtins: [ParakeetSpeechModelCatalog.Variant: ParakeetSpeechModelCatalog.Descriptor] = [.mini: ParakeetSpeechModelCatalog.mini, .pico: ParakeetSpeechModelCatalog.pico]+ XCTAssertEqual(CompactSpeechModelReleaseCatalog.descriptors(in: payload, build: 26), builtins)+ let iosOnly: [String: [String: [[String: Any]]]] = [+ "mini": ["ios": self.releaseModels()["mini"]?["macos"] ?? [], "macos": []],+ "pico": ["ios": [], "macos": []],+ ]+ let incompatible = [self.releaseModels(format: 2), self.releaseModels(minBuild: 28), iosOnly]+ for models in incompatible {+ let fallback = try SpeechModelFeed.verified(+ envelope: self.signedFeed(key: key, sequence: 6, models: models),+ publicKeys: [key.publicKey.rawRepresentation.base64EncodedString()],+ lastSequence: 5+ )+ XCTAssertEqual(CompactSpeechModelReleaseCatalog.descriptors(in: fallback, build: 27), builtins)+ }+ }++ func testCatalogCoalescesAndAcceptsRollbackOnlyUnderNewSequence() async throws {+ let key = Curve25519.Signing.PrivateKey()+ let directory = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)+ defer { try? FileManager.default.removeItem(at: directory) }+ try FileManager.default.createDirectory(at: directory, withIntermediateDirectories: true)+ let cache = directory.appendingPathComponent("feed.json")+ try self.signedFeed(key: key, sequence: 5, models: self.releaseModels()).write(to: cache)+ let gate = CompactCatalogFetchGate()+ let catalog = CompactSpeechModelReleaseCatalog(publicKeys: [key.publicKey.rawRepresentation.base64EncodedString()], cacheURL: cache, build: 27, fetch: { try await gate.fetch() })+ let first = Task { await catalog.refreshIfNeeded() }+ try await self.waitUntil { await gate.calls == 1 }+ let second = Task { await catalog.refreshIfNeeded() }+ XCTAssertEqual(catalog.snapshot.sequence, 5)+ let cached = catalog.snapshot+ try await gate.complete(.success(self.signedFeed(key: key, sequence: 4, models: self.releaseModels(release: "1.3.0"))))+ await first.value+ await second.value+ XCTAssertEqual(catalog.snapshot, cached)+ await catalog.refreshIfNeeded()+ let calls = await gate.calls+ XCTAssertEqual(calls, 1, "Failed checks retry hourly, not on every appearance")+ let retry = Task { await catalog.refreshIfNeeded(force: true) }+ try await self.waitUntil { await gate.calls == 2 }+ try await gate.complete(.success(self.signedFeed(key: key, sequence: 6, models: self.releaseModels(release: "1.0.0"))))+ await retry.value+ XCTAssertEqual(catalog.snapshot.sequence, 6)+ XCTAssertTrue(catalog.descriptor(for: .pico).archiveURL?.path.contains("/1.0.0/") == true, "Intentional rollback is allowed under a higher signed sequence")+ let retained = try SpeechModelFeed.verified(envelope: Data(contentsOf: cache), publicKeys: [key.publicKey.rawRepresentation.base64EncodedString()], lastSequence: 6)+ XCTAssertEqual(retained.sequence, 6)+ XCTAssertEqual(catalog.descriptor(for: .v3), ParakeetSpeechModelCatalog.v3)+ XCTAssertNil(catalog.descriptor(for: SettingsStore.SpeechModel.appleSpeech))+ let reopened = CompactSpeechModelReleaseCatalog(+ publicKeys: [key.publicKey.rawRepresentation.base64EncodedString()],+ cacheURL: cache,+ build: 27,+ fetch: { XCTFail("Persisted successful checks must not refetch before one day"); throw URLError(.timedOut) }+ )+ await reopened.refreshIfNeeded()+ XCTAssertEqual(reopened.snapshot.sequence, 6)+ XCTAssertEqual(reopened.descriptor(for: .mini), catalog.descriptor(for: .mini))+ }++ func testRejectionsPersistAreBoundedAndCannotChangeModelSelection() async throws {+ let directory = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)+ defer { try? FileManager.default.removeItem(at: directory) }+ let cache = directory.appendingPathComponent("feed.json")+ let catalog = CompactSpeechModelReleaseCatalog(cacheURL: cache, fetch: { throw URLError(.timedOut) })+ let selection = SettingsStore.shared.selectedSpeechModel+ let hash = try XCTUnwrap(ParakeetSpeechModelCatalog.mini.manifestSHA256)+ await catalog.reject(manifestSHA256: hash)+ let revision = catalog.revision+ await catalog.reject(manifestSHA256: hash)+ await catalog.reject(manifestSHA256: "invalid")+ XCTAssertEqual(catalog.revision, revision)+ XCTAssertEqual(catalog.snapshot.rejectedManifestHashes, [hash])+ XCTAssertEqual(catalog.descriptor(for: .mini), ParakeetSpeechModelCatalog.mini)+ XCTAssertEqual(SettingsStore.shared.selectedSpeechModel, selection)+ let reopened = CompactSpeechModelReleaseCatalog(cacheURL: cache, fetch: { throw URLError(.timedOut) })+ await reopened.refreshIfNeeded()+ XCTAssertTrue(reopened.snapshot.rejectedManifestHashes.contains(hash))+ let bounded = CompactSpeechModelReleaseCatalog(cacheURL: nil, fetch: { throw URLError(.timedOut) })+ for number in 0..<70 {+ await bounded.reject(manifestSHA256: String(format: "%064x", number))+ }+ XCTAssertEqual(bounded.snapshot.rejectedManifestHashes.count, 64)+ XCTAssertFalse(bounded.snapshot.rejectedManifestHashes.contains(String(format: "%064x", 0)))+ XCTAssertTrue(bounded.snapshot.rejectedManifestHashes.contains(String(format: "%064x", 69)))+ }++ func testCompetingCatalogsPreserveHighestSignedSequenceAndMergeRejections() async throws {+ let key = Curve25519.Signing.PrivateKey()+ let keys = [key.publicKey.rawRepresentation.base64EncodedString()]+ let directory = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)+ defer { try? FileManager.default.removeItem(at: directory) }+ try FileManager.default.createDirectory(at: directory, withIntermediateDirectories: true)+ let cache = directory.appendingPathComponent("feed.json")+ try self.signedFeed(key: key, sequence: 1, models: self.releaseModels()).write(to: cache)+ let earlierGate = CompactCatalogFetchGate()+ let laterGate = CompactCatalogFetchGate()+ let earlier = CompactSpeechModelReleaseCatalog(publicKeys: keys, cacheURL: cache, build: 27, fetch: { try await earlierGate.fetch() })+ let later = CompactSpeechModelReleaseCatalog(publicKeys: keys, cacheURL: cache, build: 27, fetch: { try await laterGate.fetch() })+ let earlierCheck = Task { await earlier.refreshIfNeeded(force: true) }+ try await self.waitUntil { await earlierGate.calls == 1 }+ let laterCheck = Task { await later.refreshIfNeeded(force: true) }+ try await self.waitUntil { await laterGate.calls == 1 }+ try await laterGate.complete(.success(self.signedFeed(key: key, sequence: 3, models: self.releaseModels(release: "1.3.0"))))+ await laterCheck.value+ try await earlierGate.complete(.success(self.signedFeed(key: key, sequence: 2, models: self.releaseModels(release: "1.2.0"))))+ await earlierCheck.value+ XCTAssertEqual(earlier.snapshot.sequence, 3, "The stale writer must adopt the higher on-disk signed feed")+ XCTAssertEqual(earlier.descriptor(for: .mini), later.descriptor(for: .mini))+ XCTAssertEqual(try SpeechModelFeed.verified(envelope: Data(contentsOf: cache), publicKeys: keys, lastSequence: 3).sequence, 3)+ let lock = open(cache.appendingPathExtension("lock").path, O_RDWR)+ XCTAssertGreaterThanOrEqual(lock, 0)+ guard lock >= 0 else { return }+ defer { Darwin.close(lock) }+ XCTAssertEqual(flock(lock, LOCK_EX | LOCK_NB), 0)+ let firstHash = String(repeating: "e", count: 64)+ let secondHash = String(repeating: "f", count: 64)+ let firstReject = Task { await earlier.reject(manifestSHA256: firstHash) }+ let secondReject = Task { await later.reject(manifestSHA256: secondHash) }+ try await self.waitUntil {+ earlier.snapshot.rejectedManifestHashes.contains(firstHash) && later.snapshot.rejectedManifestHashes.contains(secondHash)+ }+ await firstReject.value+ await secondReject.value+ XCTAssertEqual(flock(lock, LOCK_UN), 0)+ // Both bounded busy retries exhausted while the lock was held. The next+ // duplicate rejection event must flush the one retained pending state.+ await earlier.reject(manifestSHA256: firstHash)+ await later.reject(manifestSHA256: secondHash)+ let reopened = CompactSpeechModelReleaseCatalog(publicKeys: keys, cacheURL: cache, build: 27, fetch: { throw URLError(.timedOut) })+ await reopened.refreshIfNeeded()+ XCTAssertEqual(reopened.snapshot.sequence, 3)+ XCTAssertEqual(reopened.snapshot.rejectedManifestHashes, [firstHash, secondHash], "Overlapping processes must retain both failures after restart")+ XCTAssertEqual(CompactSpeechModelReleaseCatalog.cacheFolderName(bundleIdentifier: "com.FluidApp.app", isDebug: false), "FluidVoice")+ XCTAssertEqual(CompactSpeechModelReleaseCatalog.cacheFolderName(bundleIdentifier: "com.FluidApp.app.debug", isDebug: true), "FluidVoice/com.FluidApp.app.debug")+ }++ func testSuccessfulChecksWaitOneDayAndFailedChecksRetryHourly() async throws {+ let key = Curve25519.Signing.PrivateKey()+ let clock = CatalogTestClock()+ let gate = CompactCatalogFetchGate()+ let catalog = CompactSpeechModelReleaseCatalog(+ publicKeys: [key.publicKey.rawRepresentation.base64EncodedString()],+ cacheURL: nil,+ build: 27,+ now: { clock.now() },+ fetch: { try await gate.fetch() }+ )+ let first = Task { await catalog.refreshIfNeeded() }+ try await self.waitUntil { await gate.calls == 1 }+ try await gate.complete(.success(self.signedFeed(key: key, sequence: 1, models: self.releaseModels())))+ await first.value+ clock.advance(86_399)+ await catalog.refreshIfNeeded()+ let beforeDay = await gate.calls+ XCTAssertEqual(beforeDay, 1)+ clock.advance(1)+ let failure = Task { await catalog.refreshIfNeeded() }+ try await self.waitUntil { await gate.calls == 2 }+ await gate.complete(.failure(URLError(.timedOut)))+ await failure.value+ let lastGood = catalog.snapshot+ clock.advance(3599)+ await catalog.refreshIfNeeded()+ let beforeHour = await gate.calls+ XCTAssertEqual(beforeHour, 2)+ clock.advance(1)+ let retry = Task { await catalog.refreshIfNeeded() }+ try await self.waitUntil { await gate.calls == 3 }+ await gate.complete(.failure(URLError(.timedOut)))+ await retry.value+ XCTAssertEqual(catalog.snapshot, lastGood)+ }++ func testOfflineInvalidFeedKeepsBuiltInModelsUsable() async throws {+ let directory = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)+ defer { try? FileManager.default.removeItem(at: directory) }+ try FileManager.default.createDirectory(at: directory, withIntermediateDirectories: true)+ let cache = directory.appendingPathComponent("feed.json")+ try Data("{\"schema\":1,\"models\":[]}".utf8).write(to: cache)+ let catalog = CompactSpeechModelReleaseCatalog(cacheURL: cache, fetch: { throw URLError(.timedOut) })+ await catalog.refreshIfNeeded()+ XCTAssertEqual(catalog.descriptor(for: .mini), ParakeetSpeechModelCatalog.mini)+ XCTAssertEqual(catalog.descriptor(for: .pico), ParakeetSpeechModelCatalog.pico)+ XCTAssertEqual(catalog.snapshot.sequence, 0)+ }++ func testOldCompleteCompactInstallIsUsableAndHasUpdateWithActualProfileHash() async throws {+ let root = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString, isDirectory: true)+ defer { try? FileManager.default.removeItem(at: root) }+ let descriptor = ParakeetSpeechModelCatalog.mini+ let directory = descriptor.cacheDirectory(in: root)+ try FileManager.default.createDirectory(at: directory, withIntermediateDirectories: true)+ for name in descriptor.requiredModelNames {+ let artifact = directory.appendingPathComponent(name, isDirectory: true)+ try FileManager.default.createDirectory(at: artifact, withIntermediateDirectories: true)+ try FileManager.default.createDirectory(at: artifact.appendingPathComponent("weights", isDirectory: true), withIntermediateDirectories: true)+ for file in ["coremldata.bin", "metadata.json", "weights/weight.bin"] {+ try Data([1]).write(to: artifact.appendingPathComponent(file))+ }+ }+ try Data("{}".utf8).write(to: directory.appendingPathComponent(descriptor.vocabularyFile))+ let oldHash = String(repeating: "c", count: 64)+ try Data(oldHash.utf8).write(to: directory.appendingPathComponent(ParakeetSpeechModelCatalog.installationRevisionFileName))+ let probes = [SpeechModelInstallationSnapshot.Probe(modelID: descriptor.modelID, kind: .parakeet(descriptor))]+ let snapshot = SpeechModelInstallationSnapshot(capture: { probes }, resultScanner: {+ try await SpeechModelInstallationSnapshot.scanResult($0, cachesDirectory: root, modelsDirectory: root)+ })+ snapshot.refresh()+ try await self.waitUntil { snapshot.state == .ready }+ XCTAssertEqual(snapshot.installedIDs, [descriptor.modelID])+ XCTAssertEqual(snapshot.updateAvailableIDs, [descriptor.modelID])+ XCTAssertEqual(snapshot.installedArchiveHashes, [descriptor.modelID: oldHash])+ XCTAssertEqual(snapshot.installedDescriptor(for: .fluidParakeetMini)?.pronunciationModelKey, "\(descriptor.modelID):sha256:\(oldHash)")+ XCTAssertNil(snapshot.installedDescriptor(for: .appleSpeech))+ XCTAssertEqual(snapshot.latestDescriptors[descriptor.modelID], descriptor)+ XCTAssertFalse(descriptor.artifactsAreComplete(at: directory), "Old complete weights cannot count as latest")+ XCTAssertEqual(+ try Data(contentsOf: directory.appendingPathComponent(ParakeetSpeechModelCatalog.installationRevisionFileName)),+ Data(oldHash.utf8),+ "Checking cannot replace the installed checkpoint"+ )+ try Data((descriptor.archiveSHA256 ?? "").utf8).write(to: directory.appendingPathComponent(ParakeetSpeechModelCatalog.installationRevisionFileName))+ snapshot.refresh()+ try await self.waitUntil { snapshot.state == .ready }+ XCTAssertEqual(snapshot.installedIDs, [descriptor.modelID])+ XCTAssertTrue(snapshot.updateAvailableIDs.isEmpty)++ let manifestBytes = Data("{\"schema\":1}".utf8)+ let manifestHash = SHA256.hash(data: manifestBytes).map { String(format: "%02x", $0) }.joined()+ let manifestFile = directory.appendingPathComponent("manifest.json")+ try manifestBytes.write(to: manifestFile)+ let sameManifest = descriptor.replacingArchive(url: descriptor.archiveURL, sha256: oldHash, manifestSHA256: manifestHash)+ let matching = try await SpeechModelInstallationSnapshot.scanResult(+ [.init(modelID: descriptor.modelID, kind: .parakeet(sameManifest))], cachesDirectory: root, modelsDirectory: root+ )+ XCTAssertEqual(matching.installedManifestHashes, [descriptor.modelID: manifestHash])+ XCTAssertTrue(matching.updateAvailableIDs.isEmpty, "Manifest identity wins even when archive packaging differs")+ let newManifest = String(repeating: "d", count: 64)+ let update = sameManifest.replacingArchive(url: descriptor.archiveURL, sha256: oldHash, manifestSHA256: newManifest)+ let differing = try await SpeechModelInstallationSnapshot.scanResult(+ [.init(modelID: descriptor.modelID, kind: .parakeet(update))], cachesDirectory: root, modelsDirectory: root+ )+ XCTAssertEqual(differing.updateAvailableIDs, [descriptor.modelID])+ let rejected = try await SpeechModelInstallationSnapshot.scanResult(+ [.init(modelID: descriptor.modelID, kind: .parakeet(update), rejectedManifestHashes: [newManifest])], cachesDirectory: root, modelsDirectory: root+ )+ XCTAssertEqual(rejected.installedIDs, [descriptor.modelID])+ XCTAssertTrue(rejected.updateAvailableIDs.isEmpty, "A failed runtime release must not nag the user again")+ XCTAssertEqual(rejected.installedArchiveHashes, matching.installedArchiveHashes, "Feed identity must not change pronunciation checkpoint identity")+ XCTAssertEqual(try Data(contentsOf: manifestFile), manifestBytes, "Checking and rejecting cannot change installed files")+ }++ func testRapidRefreshScansOnlyInitialAndLatestSnapshotAndRejectsOldResult() async throws {+ let gate = InstallationScanGate()+ let capture = InstallationCapture()+ let snapshot = SpeechModelInstallationSnapshot(capture: {+ [.init(modelID: capture.modelID, kind: .builtIn)]+ }, scanner: { try await gate.scan($0) })+ snapshot.refresh()+ try await self.waitUntil { await gate.calls == 1 }+ capture.modelID = "middle"+ snapshot.refresh()+ capture.modelID = "latest"+ snapshot.refresh()+ await gate.complete(.success(["first"]))+ try await self.waitUntil { await gate.calls == 2 }+ XCTAssertEqual(snapshot.state, .checking)+ XCTAssertTrue(snapshot.installedIDs.isEmpty, "An outdated scan must not publish")+ XCTAssertFalse(snapshot.canUseModelActions)+ await gate.complete(.success(["latest"]))+ try await self.waitUntil { snapshot.state == .ready }+ XCTAssertEqual(snapshot.installedIDs, ["latest"])+ let observed = await gate.observedIDs+ XCTAssertEqual(observed, [["first"], ["latest"]])+ XCTAssertTrue(snapshot.canUseModelActions)+ }++ func testCancelDrainsOldWorkerBeforeRetryAndNeverPublishesCanceledResult() async throws {+ let gate = InstallationScanGate()+ let snapshot = SpeechModelInstallationSnapshot(capture: { [] }, scanner: { try await gate.scan($0) })+ snapshot.refresh()+ try await self.waitUntil { await gate.calls == 1 }+ snapshot.cancel()+ XCTAssertEqual(snapshot.state, .failed)+ snapshot.refresh()+ let beforeDrain = await gate.calls+ XCTAssertEqual(beforeDrain, 1, "A retry must not start overlapping filesystem work")+ await gate.complete(.success(["canceled"]))+ try await self.waitUntil { await gate.calls == 2 }+ XCTAssertFalse(snapshot.isInstalled(modelID: "canceled"))+ await gate.complete(.success(["retry"]))+ try await self.waitUntil { snapshot.state == .ready }+ XCTAssertEqual(snapshot.installedIDs, ["retry"])+ }++ func testFailureClearsOldIDsAndAllowsSuccessfulRetry() async throws {+ let gate = InstallationScanGate()+ let snapshot = SpeechModelInstallationSnapshot(capture: { [] }, scanner: { try await gate.scan($0) })+ snapshot.refresh()+ try await self.waitUntil { await gate.calls == 1 }+ await gate.complete(.success(["old"]))+ try await self.waitUntil { snapshot.state == .ready }+ snapshot.refresh()+ try await self.waitUntil { await gate.calls == 2 }+ await gate.complete(.failure(CocoaError(.fileReadNoSuchFile)))+ try await self.waitUntil { snapshot.state == .failed }+ XCTAssertTrue(snapshot.installedIDs.isEmpty)+ XCTAssertFalse(snapshot.canUseModelActions)+ snapshot.refresh()+ try await self.waitUntil { await gate.calls == 3 }+ await gate.complete(.success(["new"]))+ try await self.waitUntil { snapshot.state == .ready }+ XCTAssertEqual(snapshot.installedIDs, ["new"])+ }++ func testStalledIOHasBoundedFailureAndRejectsLateSuccess() async throws {+ let gate = InstallationScanGate()+ let snapshot = SpeechModelInstallationSnapshot(timeoutNanoseconds: 20_000_000, capture: { [] }, scanner: { try await gate.scan($0) })+ snapshot.refresh()+ try await self.waitUntil { await gate.calls == 1 }+ try await self.waitUntil { snapshot.state == .failed }+ XCTAssertTrue(snapshot.installedIDs.isEmpty)+ XCTAssertFalse(snapshot.canUseModelActions)+ await gate.complete(.success(["late"]))+ try await Task.sleep(for: .milliseconds(10))+ XCTAssertEqual(snapshot.state, .failed)+ XCTAssertFalse(snapshot.isInstalled(modelID: "late"))+ }++ func testCompletedDeadlineCannotCancelLaterRefresh() async throws {+ let gate = InstallationScanGate()+ let snapshot = SpeechModelInstallationSnapshot(timeoutNanoseconds: 100_000_000, capture: { [] }, scanner: { try await gate.scan($0) })+ snapshot.refresh()+ try await self.waitUntil { await gate.calls == 1 }+ await gate.complete(.success(["one"]))+ try await self.waitUntil { snapshot.state == .ready }+ try await Task.sleep(for: .milliseconds(70))+ snapshot.refresh()+ try await self.waitUntil { await gate.calls == 2 }+ try await Task.sleep(for: .milliseconds(40))+ XCTAssertEqual(snapshot.state, .checking, "The first canceled deadline must not cancel the new request")+ await gate.complete(.success(["two"]))+ try await self.waitUntil { snapshot.state == .ready }+ }++ func testOffMainScannerChecksExactWhisperSizeAndHasNoStatefulSideEffects() async throws {+ let root = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString, isDirectory: true)+ defer { try? FileManager.default.removeItem(at: root) }+ let models = root.appendingPathComponent("WhisperModels", isDirectory: true)+ try FileManager.default.createDirectory(at: models, withIntermediateDirectories: true)+ let file = models.appendingPathComponent("fixture.bin")+ try Data([1, 2, 3]).write(to: file)+ let selection = SettingsStore.shared.selectedSpeechModel+ let ids = try await SpeechModelInstallationSnapshot.scan(+ [+ .init(modelID: "bundled", kind: .builtIn),+ .init(modelID: "exact", kind: .whisper(file: "fixture.bin", expectedBytes: 3)),+ .init(modelID: "wrong-size", kind: .whisper(file: "fixture.bin", expectedBytes: 4)),+ .init(modelID: "missing", kind: .whisper(file: "missing.bin", expectedBytes: 3)),+ .init(modelID: "unsupported", kind: .unavailable),+ ],+ cachesDirectory: root,+ modelsDirectory: root+ )+ XCTAssertEqual(ids, ["bundled", "exact"])+ XCTAssertEqual(try Data(contentsOf: file), Data([1, 2, 3]))+ XCTAssertEqual(SettingsStore.shared.selectedSpeechModel, selection)+ }+}diff --git a/Tests/FluidDictationIntegrationTests/UpdateAppReplacementTests.swift b/Tests/FluidDictationIntegrationTests/UpdateAppReplacementTests.swiftnew file mode 100644index 00000000..a4529361--- /dev/null+++ b/Tests/FluidDictationIntegrationTests/UpdateAppReplacementTests.swift@@ -0,0 +1,409 @@+@testable import FluidVoice_Debug+import Foundation+import XCTest++final class UpdateAppReplacementTests: XCTestCase {+ func testCommitKeepsInstalledNameSourceAndUnrelatedDestination() throws {+ let fixture = try Fixture()+ defer { fixture.cleanup() }+ let unrelated = try fixture.bundle("DownloadedName.app", parent: fixture.applications, contents: "unrelated")+ let replacement = try UpdateAppReplacement.prepare(installedAppURL: fixture.installed, replacementAppURL: fixture.source)+ XCTAssertEqual(try fixture.contents(fixture.installed), "old")+ XCTAssertEqual(try fixture.contents(replacement.stagedAppURL), "new")+ try replacement.commit()+ XCTAssertEqual(try fixture.contents(fixture.installed), "new")+ XCTAssertEqual(replacement.installedAppURL, fixture.installed)+ XCTAssertEqual(try fixture.contents(replacement.recoveryAppURL), "old")+ XCTAssertEqual(try fixture.contents(fixture.source), "new")+ XCTAssertEqual(try fixture.contents(unrelated), "unrelated")+ try replacement.finalize()+ XCTAssertFalse(FileManager.default.fileExists(atPath: replacement.stagingDirectoryURL.path))+ XCTAssertEqual(try fixture.contents(fixture.backup), "old")+ XCTAssertEqual(try fixture.contents(fixture.installed), "new")+ }++ func testFailedRelaunchRecoveryRestoresOldBundleWithoutConsumingRollbackSource() throws {+ let fixture = try Fixture()+ defer { fixture.cleanup() }+ let replacement = try UpdateAppReplacement.prepare(installedAppURL: fixture.installed, replacementAppURL: fixture.backup)+ try replacement.commit()+ try replacement.recover()+ XCTAssertEqual(try fixture.contents(fixture.installed), "old")+ XCTAssertEqual(try fixture.contents(fixture.backup), "old")+ XCTAssertFalse(FileManager.default.fileExists(atPath: replacement.stagingDirectoryURL.path))+ }++ func testPreparationFailureDoesNotChangeInstalledBundle() throws {+ let fixture = try Fixture()+ defer { fixture.cleanup() }+ var operations = UpdateAppReplacement.Operations.live+ operations.copyBundle = { _, destination in+ try FileManager.default.createDirectory(at: destination, withIntermediateDirectories: false)+ throw ProbeFailure.injected+ }+ XCTAssertThrowsError(try UpdateAppReplacement.prepare(installedAppURL: fixture.installed, replacementAppURL: fixture.source, operations: operations))+ XCTAssertEqual(try fixture.contents(fixture.installed), "old")+ XCTAssertEqual(try fixture.contents(fixture.source), "new")+ XCTAssertEqual(try FileManager.default.contentsOfDirectory(atPath: fixture.applications.path).filter { $0.hasSuffix(".staging") }, [])+ }++ func testCreateFailureCannotDeleteAnUnownedDirectory() throws {+ let fixture = try Fixture()+ defer { fixture.cleanup() }+ let removals = Counter()+ var operations = UpdateAppReplacement.Operations.live+ operations.createDirectory = { _ in throw ProbeFailure.injected }+ operations.removeDirectory = { _ in _ = removals.next() }+ XCTAssertThrowsError(try UpdateAppReplacement.prepare(installedAppURL: fixture.installed, replacementAppURL: fixture.source, operations: operations))+ XCTAssertEqual(removals.value, 0)+ XCTAssertEqual(try fixture.contents(fixture.installed), "old")+ }++ func testExchangeFailurePreservesOldBundleAndPreparedCopyCanBeDiscarded() throws {+ let fixture = try Fixture()+ defer { fixture.cleanup() }+ var operations = UpdateAppReplacement.Operations.live+ operations.exchangeBundles = { _, _ in throw ProbeFailure.injected }+ let replacement = try UpdateAppReplacement.prepare(installedAppURL: fixture.installed, replacementAppURL: fixture.source, operations: operations)+ XCTAssertThrowsError(try replacement.commit())+ XCTAssertEqual(try fixture.contents(fixture.installed), "old")+ XCTAssertEqual(try fixture.contents(replacement.stagedAppURL), "new")+ try replacement.discardPrepared()+ XCTAssertFalse(FileManager.default.fileExists(atPath: replacement.stagingDirectoryURL.path))+ }++ func testRecoveryFailureRetainsBothBundlesAndAllowsRetry() throws {+ let fixture = try Fixture()+ defer { fixture.cleanup() }+ let exchanges = Counter()+ var operations = UpdateAppReplacement.Operations.live+ operations.exchangeBundles = { installed, staged in+ if exchanges.next() == 2 { throw ProbeFailure.injected }+ try UpdateAppReplacement.Operations.live.exchangeBundles(installed, staged)+ }+ let replacement = try UpdateAppReplacement.prepare(installedAppURL: fixture.installed, replacementAppURL: fixture.source, operations: operations)+ try replacement.commit()+ XCTAssertThrowsError(try replacement.recover()) { error in+ XCTAssertEqual((error as? UpdateAppReplacement.Failure)?.operation, .recovery)+ XCTAssertEqual((error as? UpdateAppReplacement.Failure)?.recoveryDirectoryURL, replacement.stagingDirectoryURL)+ }+ XCTAssertEqual(try fixture.contents(fixture.installed), "new")+ XCTAssertEqual(try fixture.contents(replacement.recoveryAppURL), "old")+ try replacement.recover()+ XCTAssertEqual(try fixture.contents(fixture.installed), "old")+ XCTAssertFalse(FileManager.default.fileExists(atPath: replacement.stagingDirectoryURL.path))+ }++ func testCleanupFailureAfterRecoveryKeepsOldInstalledAndRetriesOnlyCleanup() throws {+ let fixture = try Fixture()+ defer { fixture.cleanup() }+ let exchanges = Counter()+ let removals = Counter()+ var operations = UpdateAppReplacement.Operations.live+ operations.exchangeBundles = { installed, staged in+ _ = exchanges.next()+ try UpdateAppReplacement.Operations.live.exchangeBundles(installed, staged)+ }+ operations.removeDirectory = { directory in+ if removals.next() == 1 { throw ProbeFailure.injected }+ try UpdateAppReplacement.Operations.live.removeDirectory(directory)+ }+ let replacement = try UpdateAppReplacement.prepare(installedAppURL: fixture.installed, replacementAppURL: fixture.source, operations: operations)+ try replacement.commit()+ XCTAssertThrowsError(try replacement.recover())+ XCTAssertEqual(try fixture.contents(fixture.installed), "old")+ try replacement.recover()+ XCTAssertEqual(exchanges.value, 2)+ XCTAssertEqual(try fixture.contents(fixture.installed), "old")+ XCTAssertFalse(FileManager.default.fileExists(atPath: replacement.stagingDirectoryURL.path))+ }++ func testPartialFinalizationFailureKeepsInstalledNewAndDurableOldBackup() throws {+ let fixture = try Fixture()+ defer { fixture.cleanup() }+ let removals = Counter()+ var operations = UpdateAppReplacement.Operations.live+ operations.removeDirectory = { directory in+ if removals.next() == 1 {+ try FileManager.default.removeItem(at: directory.appendingPathComponent("FluidVoice.app/marker"))+ throw ProbeFailure.injected+ }+ try UpdateAppReplacement.Operations.live.removeDirectory(directory)+ }+ let replacement = try UpdateAppReplacement.prepare(installedAppURL: fixture.installed, replacementAppURL: fixture.source, operations: operations)+ try replacement.commit()+ XCTAssertThrowsError(try replacement.finalize())+ XCTAssertEqual(try fixture.contents(fixture.installed), "new")+ XCTAssertEqual(try fixture.contents(fixture.backup), "old")+ XCTAssertThrowsError(try replacement.recover(), "Partially cleaned old files must never replace the running new app")+ try replacement.finalize()+ XCTAssertFalse(FileManager.default.fileExists(atPath: replacement.stagingDirectoryURL.path))+ }++ func testValidationOrBackupFailureCanDiscardPreparedWithoutChangingEitherBundle() throws {+ let fixture = try Fixture()+ defer { fixture.cleanup() }+ let replacement = try UpdateAppReplacement.prepare(installedAppURL: fixture.installed, replacementAppURL: fixture.source)+ try replacement.discardPrepared()+ try replacement.discardPrepared()+ XCTAssertThrowsError(try replacement.commit())+ XCTAssertEqual(try fixture.contents(fixture.installed), "old")+ XCTAssertEqual(try fixture.contents(fixture.source), "new")+ XCTAssertEqual(try fixture.contents(fixture.backup), "old")+ }++ func testCopyAndCleanupFailureReportsOwnedRecoveryDirectory() throws {+ let fixture = try Fixture()+ defer { fixture.cleanup() }+ var operations = UpdateAppReplacement.Operations.live+ operations.copyBundle = { _, _ in throw ProbeFailure.injected }+ operations.removeDirectory = { _ in throw ProbeFailure.injected }+ XCTAssertThrowsError(try UpdateAppReplacement.prepare(installedAppURL: fixture.installed, replacementAppURL: fixture.source, operations: operations)) { error in+ let failure = error as? UpdateAppReplacement.Failure+ XCTAssertEqual(failure?.operation, .cleanup)+ XCTAssertEqual(failure?.recoveryDirectoryURL?.deletingLastPathComponent(), fixture.applications)+ XCTAssertTrue(failure?.recoveryDirectoryURL?.lastPathComponent.hasPrefix(".fluidvoice-update-") == true)+ }+ XCTAssertEqual(try fixture.contents(fixture.installed), "old")+ }++ func testRepeatedCommitIsRejectedAndSymlinkInputsAreRejected() throws {+ let fixture = try Fixture()+ defer { fixture.cleanup() }+ let replacement = try UpdateAppReplacement.prepare(installedAppURL: fixture.installed, replacementAppURL: fixture.source)+ try replacement.commit()+ XCTAssertThrowsError(try replacement.commit())+ XCTAssertEqual(try fixture.contents(fixture.installed), "new")+ try replacement.recover()+ let link = fixture.root.appendingPathComponent("Link.app")+ try FileManager.default.createSymbolicLink(at: link, withDestinationURL: fixture.source)+ XCTAssertThrowsError(try UpdateAppReplacement.prepare(installedAppURL: fixture.installed, replacementAppURL: link))+ XCTAssertEqual(try fixture.contents(fixture.installed), "old")+ }++ func testLiveTransactionLockBlocksConcurrentAttemptWithoutDeletingRecoveryOrAccumulatingCopies() throws {+ let fixture = try Fixture()+ defer { fixture.cleanup() }+ let first = try UpdateAppReplacement.prepare(installedAppURL: fixture.installed, replacementAppURL: fixture.source)+ for _ in 0..<3 {+ XCTAssertThrowsError(try UpdateAppReplacement.prepare(installedAppURL: fixture.installed, replacementAppURL: fixture.source)) { error in+ XCTAssertEqual((error as NSError).domain, NSPOSIXErrorDomain)+ XCTAssertEqual((error as NSError).code, Int(EWOULDBLOCK))+ }+ }+ XCTAssertEqual(try FileManager.default.contentsOfDirectory(atPath: fixture.applications.path).count, 3)+ XCTAssertEqual(try fixture.contents(first.stagedAppURL), "new")+ XCTAssertEqual(try fixture.contents(fixture.installed), "old")+ try first.discardPrepared()+ let retry = try UpdateAppReplacement.prepare(installedAppURL: fixture.installed, replacementAppURL: fixture.source)+ try retry.discardPrepared()+ }++ func testCallerValidationRunsUnderLockEvenWithoutStaleStage() throws {+ let fixture = try Fixture()+ defer { fixture.cleanup() }+ let validations = Counter()+ let replacement = try UpdateAppReplacement.prepare(+ installedAppURL: fixture.installed,+ replacementAppURL: fixture.source,+ validateInstalledApp: { _ in+ _ = validations.next()+ XCTAssertThrowsError(try UpdateAppReplacement.prepare(installedAppURL: fixture.installed, replacementAppURL: fixture.source))+ }+ )+ XCTAssertEqual(validations.value, 1)+ try replacement.discardPrepared()+ }++ func testOtherProcessCannotAcquireLockUntilTransactionCompletes() throws {+ let fixture = try Fixture()+ defer { fixture.cleanup() }+ let replacement = try UpdateAppReplacement.prepare(installedAppURL: fixture.installed, replacementAppURL: fixture.source)+ let lock = fixture.applications.appendingPathComponent(".fluidvoice-update-FluidVoice.app.lock")+ func childLockAttempt() throws -> Int32 {+ let process = Process()+ process.executableURL = URL(fileURLWithPath: "/usr/bin/python3")+ process.arguments = ["-c", """+ import fcntl, os, sys+ target = os.stat(sys.argv[1])+ for name in os.listdir('/dev/fd'):+ try:+ inherited = os.fstat(int(name))+ except OSError:+ continue+ if (inherited.st_dev, inherited.st_ino) == (target.st_dev, target.st_ino):+ sys.exit(43)+ with open(sys.argv[1], 'r+') as lock:+ try:+ fcntl.flock(lock.fileno(), fcntl.LOCK_EX | fcntl.LOCK_NB)+ except BlockingIOError:+ sys.exit(42)+ """, lock.path]+ try process.run()+ process.waitUntilExit()+ return process.terminationStatus+ }+ XCTAssertEqual(try childLockAttempt(), 42)+ try replacement.discardPrepared()+ XCTAssertEqual(try childLockAttempt(), 0)+ }++ func testChangedInstalledDirectoryCannotBeOverwrittenAtCommit() throws {+ let fixture = try Fixture()+ defer { fixture.cleanup() }+ let replacement = try UpdateAppReplacement.prepare(installedAppURL: fixture.installed, replacementAppURL: fixture.source)+ let moved = fixture.root.appendingPathComponent("MovedOriginal.app")+ try FileManager.default.moveItem(at: fixture.installed, to: moved)+ _ = try fixture.bundle("FluidVoice.app", parent: fixture.applications, contents: "external")+ XCTAssertThrowsError(try replacement.commit())+ XCTAssertEqual(try fixture.contents(fixture.installed), "external")+ XCTAssertEqual(try fixture.contents(moved), "old")+ try replacement.discardPrepared()+ }++ func testChangedInstalledDirectoryCannotBeOverwrittenOrDeletedDuringRecovery() throws {+ let fixture = try Fixture()+ defer { fixture.cleanup() }+ let replacement = try UpdateAppReplacement.prepare(installedAppURL: fixture.installed, replacementAppURL: fixture.source)+ try replacement.commit()+ let moved = fixture.root.appendingPathComponent("MovedNew.app")+ try FileManager.default.moveItem(at: fixture.installed, to: moved)+ _ = try fixture.bundle("FluidVoice.app", parent: fixture.applications, contents: "external")+ XCTAssertThrowsError(try replacement.recover())+ XCTAssertEqual(try fixture.contents(fixture.installed), "external")+ XCTAssertEqual(try fixture.contents(replacement.recoveryAppURL), "old")+ XCTAssertEqual(try fixture.contents(moved), "new")+ }++ func testVerifiedInstalledBundleAllowsOwnedCrashStageCleanupAndRetry() throws {+ let fixture = try Fixture()+ defer { fixture.cleanup() }+ let directory = try {+ let abandoned = try UpdateAppReplacement.prepare(installedAppURL: fixture.installed, replacementAppURL: fixture.source)+ try abandoned.commit()+ return abandoned.stagingDirectoryURL+ }()+ XCTAssertTrue(FileManager.default.fileExists(atPath: directory.path))+ XCTAssertThrowsError(try UpdateAppReplacement.prepare(installedAppURL: fixture.installed, replacementAppURL: fixture.source))+ XCTAssertEqual(try fixture.contents(directory.appendingPathComponent("FluidVoice.app")), "old")+ let replacement = try UpdateAppReplacement.prepare(+ installedAppURL: fixture.installed,+ replacementAppURL: fixture.source,+ validateInstalledApp: { url in XCTAssertEqual(try fixture.contents(url), "new") }+ )+ XCTAssertEqual(try fixture.contents(fixture.backup), "old")+ XCTAssertEqual(try fixture.contents(fixture.installed), "new")+ XCTAssertEqual(try fixture.contents(replacement.stagedAppURL), "new")+ try replacement.discardPrepared()+ }++ func testRejectedInstalledValidationPreservesOwnedStaleRecovery() throws {+ let fixture = try Fixture()+ defer { fixture.cleanup() }+ let directory = try {+ let abandoned = try UpdateAppReplacement.prepare(installedAppURL: fixture.installed, replacementAppURL: fixture.source)+ try abandoned.commit()+ return abandoned.stagingDirectoryURL+ }()+ XCTAssertThrowsError(try UpdateAppReplacement.prepare(+ installedAppURL: fixture.installed,+ replacementAppURL: fixture.source,+ validateInstalledApp: { _ in throw ProbeFailure.injected }+ ))+ XCTAssertEqual(try fixture.contents(directory.appendingPathComponent("FluidVoice.app")), "old")+ XCTAssertEqual(try fixture.contents(fixture.installed), "new")+ }++ func testUnknownStagingDirectoryIsNeverRemoved() throws {+ let fixture = try Fixture()+ defer { fixture.cleanup() }+ let directory = fixture.applications.appendingPathComponent(".fluidvoice-update-FluidVoice.app.staging")+ try FileManager.default.createDirectory(at: directory, withIntermediateDirectories: false)+ try Data("unrelated".utf8).write(to: directory.appendingPathComponent("valuable"))+ XCTAssertThrowsError(try UpdateAppReplacement.prepare(+ installedAppURL: fixture.installed,+ replacementAppURL: fixture.source,+ validateInstalledApp: { _ in }+ ))+ XCTAssertEqual(try String(contentsOf: directory.appendingPathComponent("valuable"), encoding: .utf8), "unrelated")+ XCTAssertEqual(try fixture.contents(fixture.installed), "old")+ }++ func testStagingSymlinkAndLockSymlinkAreNeverFollowedOrRemoved() throws {+ let fixture = try Fixture()+ defer { fixture.cleanup() }+ let directory = fixture.applications.appendingPathComponent(".fluidvoice-update-FluidVoice.app.staging")+ try FileManager.default.createSymbolicLink(at: directory, withDestinationURL: fixture.source)+ XCTAssertThrowsError(try UpdateAppReplacement.prepare(+ installedAppURL: fixture.installed,+ replacementAppURL: fixture.source,+ validateInstalledApp: { _ in }+ ))+ XCTAssertEqual(try fixture.contents(fixture.source), "new")+ try FileManager.default.removeItem(at: directory)+ let lock = fixture.applications.appendingPathComponent(".fluidvoice-update-FluidVoice.app.lock")+ try FileManager.default.removeItem(at: lock)+ try FileManager.default.createSymbolicLink(at: lock, withDestinationURL: fixture.source.appendingPathComponent("marker"))+ XCTAssertThrowsError(try UpdateAppReplacement.prepare(installedAppURL: fixture.installed, replacementAppURL: fixture.source))+ XCTAssertEqual(try fixture.contents(fixture.source), "new")+ XCTAssertEqual(try fixture.contents(fixture.installed), "old")+ }++ private enum ProbeFailure: Error { case injected }++ private final class Counter: @unchecked Sendable {+ private let lock = NSLock()+ private var count = 0+ var value: Int {+ self.lock.lock()+ defer { self.lock.unlock() }+ return self.count+ }++ func next() -> Int {+ self.lock.lock()+ defer { self.lock.unlock() }+ self.count += 1+ return self.count+ }+ }++ private struct Fixture: Sendable {+ let root: URL+ let applications: URL+ let installed: URL+ let source: URL+ let backup: URL++ init() throws {+ let root = FileManager.default.temporaryDirectory.appendingPathComponent("fluidvoice-replacement-tests-\(UUID().uuidString)", isDirectory: true)+ self.root = root+ self.applications = root.appendingPathComponent("Applications", isDirectory: true)+ try FileManager.default.createDirectory(at: self.applications, withIntermediateDirectories: true)+ let downloads = root.appendingPathComponent("Downloads", isDirectory: true)+ try FileManager.default.createDirectory(at: downloads, withIntermediateDirectories: false)+ self.installed = self.applications.appendingPathComponent("FluidVoice.app", isDirectory: true)+ self.source = downloads.appendingPathComponent("DownloadedName.app", isDirectory: true)+ self.backup = root.appendingPathComponent("Rollback.app", isDirectory: true)+ for (url, value) in [(self.installed, "old"), (self.source, "new"), (self.backup, "old")] {+ try FileManager.default.createDirectory(at: url, withIntermediateDirectories: false)+ try Data(value.utf8).write(to: url.appendingPathComponent("marker"))+ }+ }++ func bundle(_ name: String, parent: URL, contents: String) throws -> URL {+ let url = parent.appendingPathComponent(name, isDirectory: true)+ try FileManager.default.createDirectory(at: url, withIntermediateDirectories: false)+ try Data(contents.utf8).write(to: url.appendingPathComponent("marker"))+ return url+ }++ func contents(_ url: URL) throws -> String {+ try String(contentsOf: url.appendingPathComponent("marker"), encoding: .utf8)+ }++ func cleanup() {+ try? FileManager.default.removeItem(at: self.root)+ }+ }+}diff --git a/Tests/FluidDictationIntegrationTests/UpdateBundleValidatorTests.swift b/Tests/FluidDictationIntegrationTests/UpdateBundleValidatorTests.swiftnew file mode 100644index 00000000..a6d650cc--- /dev/null+++ b/Tests/FluidDictationIntegrationTests/UpdateBundleValidatorTests.swift@@ -0,0 +1,370 @@+import CryptoKit+import Darwin+@testable import FluidVoice_Debug+import Foundation+import Security+import XCTest++final nonisolated class UpdateBundleValidatorTests: XCTestCase {+ private let identifier = "com.fluidvoice.update-validator.fixture"+ private let version = "1.6.10-beta.8"++ func testMissingBundleIsRejected() {+ let missing = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString + ".app")+ XCTAssertThrowsError(try UpdateBundleValidator.validate(+ at: missing,+ expectation: self.expectation,+ policy: .developerID(allowedTeamIDs: ["V4J43B279J"])+ )) { XCTAssertEqual($0 as? UpdateBundleValidator.ValidationError, .invalidBundle) }+ }++ func testUnsignedBundleIsRejected() throws {+ try self.withFixture(sign: false) { fixture in+ XCTAssertThrowsError(try self.validate(fixture))+ }+ }++ func testDevelopmentFixtureAndInstalledPolicyPreserveExactMetadata() throws {+ try self.withFixture { fixture in+ let result = try self.validate(fixture)+ XCTAssertEqual(result.bundleIdentifier, self.identifier)+ XCTAssertEqual(result.version, self.version)+ XCTAssertEqual(result.build, "27")+ XCTAssertEqual(result.teamIdentifier, fixture.team)+ XCTAssertEqual(try UpdateBundleValidator.validate(+ at: fixture.bundle,+ expectation: self.expectation,+ policy: .installedApp(allowedTeamIDs: [fixture.team])+ ), result)+ }+ }++ func testDownloadedReleasePolicyRejectsDevelopmentCertificate() throws {+ try self.withFixture { fixture in+ XCTAssertThrowsError(try UpdateBundleValidator.validate(+ at: fixture.bundle,+ expectation: self.expectation,+ policy: .developerID(allowedTeamIDs: [fixture.team])+ ))+ }+ }++ func testDeveloperIDReleaseAcceptsApprovedSigningTeams() throws {+ try self.withFixture(developerID: true) { fixture in+ let approved: Set<String> = ["V4J43B279J", "537RRRT57V"]+ let result = try UpdateBundleValidator.validate(+ at: fixture.bundle,+ expectation: self.expectation,+ policy: .developerID(allowedTeamIDs: approved)+ )+ XCTAssertTrue(approved.contains(result.teamIdentifier))+ XCTAssertEqual(result.version, self.version)+ XCTAssertEqual(result.build, "27")+ }+ }++ func testUnapprovedTeamIsRejected() throws {+ try self.withFixture { fixture in+ XCTAssertThrowsError(try UpdateBundleValidator.validate(+ at: fixture.bundle,+ expectation: self.expectation,+ policy: .appleDevelopment(allowedTeamIDs: ["0000000000"])+ ))+ }+ }++ func testDifferentApplicationIdentityIsRejected() throws {+ try self.withFixture(identifier: "com.fluidvoice.some-other-app") { fixture in+ XCTAssertThrowsError(try self.validate(fixture)) {+ XCTAssertEqual($0 as? UpdateBundleValidator.ValidationError, .identityMismatch)+ }+ }+ }++ func testDifferentReleaseVersionIsRejectedButRollbackInspectionAllowsIt() throws {+ try self.withFixture(version: "1.6.10-beta.7") { fixture in+ XCTAssertThrowsError(try self.validate(fixture)) {+ XCTAssertEqual($0 as? UpdateBundleValidator.ValidationError, .versionMismatch)+ }+ let rollback = try UpdateBundleValidator.validate(+ at: fixture.bundle,+ expectation: .init(bundleIdentifier: self.identifier, version: nil),+ policy: .installedApp(allowedTeamIDs: [fixture.team])+ )+ XCTAssertEqual(rollback.version, "1.6.10-beta.7")+ }+ }++ func testExpectedBuildMismatchAndMalformedBuildAreRejected() throws {+ try self.withFixture { fixture in+ XCTAssertThrowsError(try UpdateBundleValidator.validate(+ at: fixture.bundle,+ expectation: .init(bundleIdentifier: self.identifier, version: self.version, build: "28"),+ policy: .appleDevelopment(allowedTeamIDs: [fixture.team])+ )) { XCTAssertEqual($0 as? UpdateBundleValidator.ValidationError, .buildMismatch) }+ }+ try self.withFixture(build: "not-a-build") { fixture in+ XCTAssertThrowsError(try self.validate(fixture)) {+ XCTAssertEqual($0 as? UpdateBundleValidator.ValidationError, .invalidBundleMetadata)+ }+ }+ }++ func testTamperedResourceIsRejectedAlthoughSigningMetadataIsStillReadable() throws {+ try self.withFixture { fixture in+ try Data("changed after signing".utf8).write(to: fixture.resource)+ XCTAssertEqual(try self.signingTeam(at: fixture.bundle), fixture.team)+ XCTAssertThrowsError(try self.validate(fixture))+ }+ }++ func testTamperedNestedResourceIsRejectedAlthoughOuterSignatureStillPasses() throws {+ try self.withFixture(nested: true) { fixture in+ XCTAssertNoThrow(try self.validate(fixture))+ let nested = fixture.bundle.appendingPathComponent("Contents/PlugIns/Nested.app")+ try Data("changed nested resource".utf8).write(to: nested.appendingPathComponent("Contents/Resources/payload.txt"))+ var code: SecStaticCode?+ XCTAssertEqual(SecStaticCodeCreateWithPath(fixture.bundle as CFURL, [], &code), errSecSuccess)+ let outerCode = try XCTUnwrap(code)+ let outerOnly = SecCSFlags(rawValue: kSecCSCheckAllArchitectures | kSecCSStrictValidate)+ XCTAssertEqual(SecStaticCodeCheckValidity(outerCode, outerOnly, nil), errSecSuccess)+ XCTAssertThrowsError(try self.validate(fixture))+ }+ }++ func testTamperedNonNativeArchitectureIsRejected() throws {+ try self.withFixture { fixture in+ XCTAssertNoThrow(try self.validate(fixture))+ let executable = fixture.bundle.appendingPathComponent("Contents/MacOS/Fixture")+ var bytes = try Data(contentsOf: executable)+ // /usr/bin/true is a universal binary on the test Mac. Damage only the+ // other architecture so validating just the native slice would miss it.+ #if arch(arm64)+ let otherCPU: UInt32 = 0x01000007+ #else+ let otherCPU: UInt32 = 0x0100000c+ #endif+ let damaged = try self.textByteOffset(in: bytes, cpu: otherCPU)+ bytes[damaged] ^= 0x01+ try bytes.write(to: executable)+ var code: SecStaticCode?+ XCTAssertEqual(SecStaticCodeCreateWithPath(fixture.bundle as CFURL, [], &code), errSecSuccess)+ XCTAssertEqual(try SecStaticCodeCheckValidity(XCTUnwrap(code), SecCSFlags(rawValue: kSecCSStrictValidate), nil), errSecSuccess)+ XCTAssertThrowsError(try self.validate(fixture))+ }+ }++ func testTamperedNestedExecutableIsRejected() throws {+ try self.withFixture(nested: true) { fixture in+ XCTAssertNoThrow(try self.validate(fixture))+ let executable = fixture.bundle.appendingPathComponent("Contents/PlugIns/Nested.app/Contents/MacOS/Fixture")+ var bytes = try Data(contentsOf: executable)+ let damaged = try self.textByteOffset(in: bytes)+ bytes[damaged] ^= 0x01+ try bytes.write(to: executable)+ var code: SecStaticCode?+ XCTAssertEqual(SecStaticCodeCreateWithPath(fixture.bundle as CFURL, [], &code), errSecSuccess)+ XCTAssertEqual(try SecStaticCodeCheckValidity(XCTUnwrap(code), SecCSFlags(rawValue: kSecCSStrictValidate), nil), errSecSuccess)+ XCTAssertThrowsError(try self.validate(fixture))+ }+ }++ func testInvalidExpectationFailsClosed() {+ XCTAssertThrowsError(try UpdateBundleValidator.validate(+ at: URL(fileURLWithPath: "/unused.app"),+ expectation: .init(bundleIdentifier: self.identifier, version: self.version),+ policy: .developerID(allowedTeamIDs: [])+ )) { XCTAssertEqual($0 as? UpdateBundleValidator.ValidationError, .invalidExpectation) }+ }++ private var expectation: UpdateBundleValidator.Expectation {+ .init(bundleIdentifier: self.identifier, version: self.version, build: "27")+ }++ private struct Fixture {+ let bundle: URL+ let team: String+ var resource: URL { self.bundle.appendingPathComponent("Contents/Resources/payload.txt") }+ }++ private func validate(_ fixture: Fixture) throws -> UpdateBundleValidator.ValidatedBundle {+ try UpdateBundleValidator.validate(at: fixture.bundle, expectation: self.expectation, policy: .appleDevelopment(allowedTeamIDs: [fixture.team]))+ }++ private func withFixture(+ identifier: String? = nil,+ version: String? = nil,+ build: String = "27",+ sign: Bool = true,+ nested: Bool = false,+ developerID: Bool = false,+ body: (Fixture) throws -> Void+ ) throws {+ let root = FileManager.default.temporaryDirectory.appendingPathComponent("UpdateBundleValidatorTests-" + UUID().uuidString, isDirectory: true)+ try FileManager.default.createDirectory(at: root, withIntermediateDirectories: true)+ defer { try? FileManager.default.removeItem(at: root) }+ let bundle = root.appendingPathComponent("Fixture.app", isDirectory: true)+ try self.makeBundle(at: bundle, identifier: identifier ?? self.identifier, version: version ?? self.version, build: build)+ if !sign {+ // The copied executable retains Apple's signature, but the enclosing+ // application has never been signed and has no sealed resource envelope.+ try body(Fixture(bundle: bundle, team: "V4J43B279J"))+ return+ }+ let identity = try self.signingIdentity(developerID: developerID)+ if nested {+ let nestedBundle = bundle.appendingPathComponent("Contents/PlugIns/Nested.app", isDirectory: true)+ try self.makeBundle(at: nestedBundle, identifier: self.identifier + ".nested", version: self.version, build: build)+ try self.sign(nestedBundle, identity: identity)+ }+ try self.sign(bundle, identity: identity)+ try body(Fixture(bundle: bundle, team: self.signingTeam(at: bundle)))+ }++ private func makeBundle(at bundle: URL, identifier: String, version: String, build: String) throws {+ let executableDirectory = bundle.appendingPathComponent("Contents/MacOS", isDirectory: true)+ let resources = bundle.appendingPathComponent("Contents/Resources", isDirectory: true)+ try FileManager.default.createDirectory(at: executableDirectory, withIntermediateDirectories: true)+ try FileManager.default.createDirectory(at: resources, withIntermediateDirectories: true)+ try FileManager.default.copyItem(at: URL(fileURLWithPath: "/usr/bin/true"), to: executableDirectory.appendingPathComponent("Fixture"))+ try Data("original resource".utf8).write(to: resources.appendingPathComponent("payload.txt"))+ let plist = [+ "CFBundleIdentifier": identifier,+ "CFBundleShortVersionString": version,+ "CFBundleVersion": build,+ "CFBundleExecutable": "Fixture",+ "CFBundlePackageType": "APPL",+ ]+ try PropertyListSerialization.data(fromPropertyList: plist, format: .xml, options: 0)+ .write(to: bundle.appendingPathComponent("Contents/Info.plist"))+ }++ private func signingIdentity(developerID: Bool) throws -> String {+ let prefix = developerID ? "Developer ID Application:" : "Apple Development:"+ var result: CFTypeRef?+ let query: [String: Any] = [kSecClass as String: kSecClassIdentity, kSecReturnRef as String: true, kSecMatchLimit as String: kSecMatchLimitAll]+ let status = SecItemCopyMatching(query as CFDictionary, &result)+ guard status == errSecSuccess, let identities = result as? [SecIdentity] else {+ throw XCTSkip("A \(prefix) signing identity is required for signed bundle fixtures.")+ }+ for identity in identities {+ var certificate: SecCertificate?+ guard SecIdentityCopyCertificate(identity, &certificate) == errSecSuccess, let certificate,+ let summary = SecCertificateCopySubjectSummary(certificate) as String?, summary.hasPrefix(prefix)+ else { continue }+ var trust: SecTrust?+ guard let policy = SecPolicyCreateWithProperties(kSecPolicyAppleCodeSigning, nil),+ SecTrustCreateWithCertificates(certificate, policy, &trust) == errSecSuccess, let trust,+ SecTrustSetNetworkFetchAllowed(trust, false) == errSecSuccess,+ SecTrustEvaluateWithError(trust, nil)+ else { continue }+ return Insecure.SHA1.hash(data: SecCertificateCopyData(certificate) as Data).map { String(format: "%02x", $0) }.joined()+ }+ throw XCTSkip("A valid \(prefix) signing identity is required for signed bundle fixtures.")+ }++ private func signingTeam(at bundle: URL) throws -> String {+ var code: SecStaticCode?+ XCTAssertEqual(SecStaticCodeCreateWithPath(bundle as CFURL, [], &code), errSecSuccess)+ let staticCode = try XCTUnwrap(code)+ var result: CFDictionary?+ XCTAssertEqual(SecCodeCopySigningInformation(staticCode, SecCSFlags(rawValue: kSecCSSigningInformation), &result), errSecSuccess)+ let information = try XCTUnwrap(result as? [String: Any])+ return try XCTUnwrap(information[kSecCodeInfoTeamIdentifier as String] as? String)+ }++ private func sign(_ bundle: URL, identity: String) throws {+ let log = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString + ".codesign.log")+ XCTAssertTrue(FileManager.default.createFile(atPath: log.path, contents: nil))+ let output = try FileHandle(forWritingTo: log)+ defer {+ try? output.close()+ try? FileManager.default.removeItem(at: log)+ }+ let process = Process()+ process.executableURL = URL(fileURLWithPath: "/usr/bin/codesign")+ process.arguments = ["--force", "--sign", identity, "--timestamp=none", bundle.path]+ process.standardOutput = output+ process.standardError = output+ try process.run()+ let deadline = Date().addingTimeInterval(15)+ while process.isRunning, Date() < deadline {+ Thread.sleep(forTimeInterval: 0.01)+ }+ if process.isRunning {+ process.terminate()+ let terminationDeadline = Date().addingTimeInterval(1)+ while process.isRunning, Date() < terminationDeadline {+ Thread.sleep(forTimeInterval: 0.01)+ }+ if process.isRunning { kill(process.processIdentifier, SIGKILL) }+ XCTFail("Temporary fixture signing exceeded its bounded timeout.")+ throw NSError(domain: "UpdateBundleValidatorTests", code: 1)+ }+ guard process.terminationStatus == 0 else {+ let diagnostic = (try? String(contentsOf: log, encoding: .utf8)) ?? "No signing diagnostic"+ XCTFail("Temporary fixture signing failed: \(diagnostic)")+ throw NSError(domain: "UpdateBundleValidatorTests", code: Int(process.terminationStatus))+ }+ }++ private func bigEndian32(_ data: Data, at offset: Int) -> UInt32 {+ guard offset >= 0, offset + 4 <= data.count else { return 0 }+ return data[offset..<offset + 4].reduce(0) { ($0 << 8) | UInt32($1) }+ }++ /// Mutate sealed executable instructions, never padding inside a signature blob.+ private func textByteOffset(in data: Data, cpu: UInt32? = nil) throws -> Int {+ guard self.bigEndian32(data, at: 0) == 0xcafebabe else {+ throw XCTSkip("The system fixture is not a 32-bit-header universal binary.")+ }+ let count = Int(self.bigEndian32(data, at: 4))+ guard (1...16).contains(count), 8 + count * 20 <= data.count else {+ throw NSError(domain: "UpdateBundleValidatorTests.MachO", code: 1)+ }+ let header = try XCTUnwrap((0..<count).map { 8 + $0 * 20 }.first {+ cpu == nil || self.bigEndian32(data, at: $0) == cpu+ })+ let slice = Int(self.bigEndian32(data, at: header + 8))+ let sliceSize = Int(self.bigEndian32(data, at: header + 12))+ guard slice + 32 <= data.count, sliceSize >= 32, slice + sliceSize <= data.count,+ self.littleEndian32(data, at: slice) == 0xfeedfacf+ else { throw NSError(domain: "UpdateBundleValidatorTests.MachO", code: 2) }+ let commands = Int(self.littleEndian32(data, at: slice + 16))+ let commandsSize = Int(self.littleEndian32(data, at: slice + 20))+ let commandsEnd = slice + 32 + commandsSize+ guard (1...128).contains(commands), commandsEnd <= slice + sliceSize else {+ throw NSError(domain: "UpdateBundleValidatorTests.MachO", code: 3)+ }+ var cursor = slice + 32+ for _ in 0..<commands {+ guard cursor + 8 <= commandsEnd else { break }+ let kind = self.littleEndian32(data, at: cursor)+ let size = Int(self.littleEndian32(data, at: cursor + 4))+ guard size >= 8, cursor + size <= commandsEnd else { break }+ if kind == 0x19, size >= 72 {+ let sections = Int(self.littleEndian32(data, at: cursor + 64))+ guard sections <= 128, 72 + sections * 80 <= size else { break }+ for section in 0..<sections {+ let position = cursor + 72 + section * 80+ let name = String(bytes: data[position..<position + 16].prefix { $0 != 0 }, encoding: .utf8)+ if name == "__text" {+ let offset = Int(self.littleEndian32(data, at: position + 48))+ let sectionSize = Int(self.littleEndian32(data, at: position + 40))+ guard sectionSize > 0, offset + sectionSize <= sliceSize,+ self.littleEndian32(data, at: position + 44) == 0+ else { break }+ return slice + offset + sectionSize / 2+ }+ }+ }+ cursor += size+ }+ throw NSError(domain: "UpdateBundleValidatorTests.MachO", code: 4)+ }++ private func littleEndian32(_ data: Data, at offset: Int) -> UInt32 {+ guard offset >= 0, offset + 4 <= data.count else { return 0 }+ return data[offset..<offset + 4].reversed().reduce(0) { ($0 << 8) | UInt32($1) }+ }+}diff --git a/Tests/FluidDictationIntegrationTests/UpdateInstallationPipelineTests.swift b/Tests/FluidDictationIntegrationTests/UpdateInstallationPipelineTests.swiftnew file mode 100644index 00000000..b6ba7867--- /dev/null+++ b/Tests/FluidDictationIntegrationTests/UpdateInstallationPipelineTests.swift@@ -0,0 +1,322 @@+import CryptoKit+import Darwin+@testable import FluidVoice_Debug+import Foundation+import Security+import XCTest++final nonisolated class UpdateInstallationPipelineTests: XCTestCase {+ func testReleaseInstallationHasVerifiedBackupAndCanRecoverWithoutConsumingSource() throws {+ let fixture = try Fixture()+ defer { fixture.cleanup() }+ let installation = try fixture.prepare()+ XCTAssertEqual(installation.backupURL, fixture.backup)+ XCTAssertEqual(try fixture.validated(fixture.installed).version, Fixture.incomingVersion)+ XCTAssertEqual(try fixture.validated(fixture.backup).version, Fixture.installedVersion)+ XCTAssertEqual(try fixture.validated(fixture.backup).build, Fixture.installedBuild)+ XCTAssertEqual(try fixture.payload(fixture.backup), "installed")+ XCTAssertEqual(try fixture.payload(installation.replacement.recoveryAppURL), "installed")+ XCTAssertEqual(try fixture.payload(fixture.incoming), "incoming")+ try installation.replacement.recover()+ XCTAssertEqual(try fixture.validated(fixture.installed).version, Fixture.installedVersion)+ XCTAssertEqual(try fixture.payload(fixture.installed), "installed")+ XCTAssertEqual(try fixture.validated(fixture.incoming).version, Fixture.incomingVersion)+ XCTAssertEqual(try fixture.validated(fixture.backup).version, Fixture.installedVersion)+ XCTAssertFalse(FileManager.default.fileExists(atPath: installation.replacement.stagingDirectoryURL.path))+ }++ func testTamperedCandidateCannotReplaceOriginalOrCreateBackup() throws {+ let fixture = try Fixture()+ defer { fixture.cleanup() }+ let originalPlist = try Data(contentsOf: fixture.installed.appendingPathComponent("Contents/Info.plist"))+ try Data("tampered incoming".utf8).write(to: fixture.incoming.appendingPathComponent("Contents/Resources/payload.txt"))+ XCTAssertThrowsError(try fixture.prepare())+ XCTAssertEqual(try Data(contentsOf: fixture.installed.appendingPathComponent("Contents/Info.plist")), originalPlist)+ try fixture.assertOriginalUnchanged()+ XCTAssertEqual(try fixture.payload(fixture.incoming), "tampered incoming")+ XCTAssertFalse(FileManager.default.fileExists(atPath: fixture.backup.path))+ try fixture.assertNoStage()+ }++ func testInstalledVersionChangedSinceApprovalRejectsPreparation() throws {+ let fixture = try Fixture()+ defer { fixture.cleanup() }+ XCTAssertThrowsError(try fixture.prepare(installedVersion: "1.6.10-beta.6")) { error in+ self.assertInstalledChanged(error)+ }+ try fixture.assertOriginalUnchanged()+ XCTAssertFalse(FileManager.default.fileExists(atPath: fixture.backup.path))+ try fixture.assertNoStage()+ }++ func testInstalledBuildChangedSinceApprovalRejectsPreparation() throws {+ let fixture = try Fixture()+ defer { fixture.cleanup() }+ XCTAssertThrowsError(try fixture.prepare(installedBuild: "25")) { error in+ self.assertInstalledChanged(error)+ }+ try fixture.assertOriginalUnchanged()+ XCTAssertFalse(FileManager.default.fileExists(atPath: fixture.backup.path))+ try fixture.assertNoStage()+ }++ func testPreexistingBackupDestinationIsPreservedAndOriginalIsUntouched() throws {+ let fixture = try Fixture()+ defer { fixture.cleanup() }+ try FileManager.default.createDirectory(at: fixture.backup.deletingLastPathComponent(), withIntermediateDirectories: true)+ try FileManager.default.copyItem(at: fixture.incoming, to: fixture.backup)+ let before = try Data(contentsOf: fixture.backup.appendingPathComponent("Contents/Info.plist"))+ XCTAssertThrowsError(try fixture.prepare()) { error in+ guard case .backupFailed? = error as? SimpleUpdateError else { return XCTFail("Expected backup failure: \(error)") }+ }+ XCTAssertEqual(try Data(contentsOf: fixture.backup.appendingPathComponent("Contents/Info.plist")), before)+ XCTAssertEqual(try fixture.validated(fixture.backup).version, Fixture.incomingVersion)+ XCTAssertEqual(try fixture.payload(fixture.backup), "incoming")+ try fixture.assertOriginalUnchanged()+ try fixture.assertNoStage()+ }++ func testRegularFileAtBackupParentAbortsWithoutReplacingOriginal() throws {+ let fixture = try Fixture()+ defer { fixture.cleanup() }+ let parent = fixture.backup.deletingLastPathComponent()+ let marker = Data("unrelated existing file".utf8)+ try marker.write(to: parent)+ XCTAssertThrowsError(try fixture.prepare()) { error in+ guard case .backupFailed? = error as? SimpleUpdateError else { return XCTFail("Expected backup failure: \(error)") }+ }+ XCTAssertEqual(try Data(contentsOf: parent), marker)+ XCTAssertFalse(FileManager.default.fileExists(atPath: fixture.backup.path))+ try fixture.assertOriginalUnchanged()+ try fixture.assertNoStage()+ }++ func testDevelopmentCandidateIsRejectedAsReleaseButAcceptedAsRollbackAndRetained() throws {+ let fixture = try Fixture(incomingDeveloperID: false, candidateVersion: "1.6.10-beta.6")+ defer { fixture.cleanup() }+ XCTAssertThrowsError(try fixture.prepare(expectedVersion: fixture.candidateVersion)) { error in+ guard case .invalidSignature? = error as? UpdateBundleValidator.ValidationError else {+ return XCTFail("Expected the release policy to reject a development certificate: \(error)")+ }+ }+ try fixture.assertOriginalUnchanged()+ XCTAssertFalse(FileManager.default.fileExists(atPath: fixture.backup.path))+ try fixture.assertNoStage()++ let installation = try fixture.prepare(expectedVersion: nil, isRollback: true)+ XCTAssertEqual(try fixture.validated(fixture.installed).version, fixture.candidateVersion)+ XCTAssertEqual(try fixture.validated(fixture.incoming).version, fixture.candidateVersion)+ XCTAssertEqual(try fixture.validated(fixture.backup).version, Fixture.installedVersion)+ try installation.replacement.finalize()+ XCTAssertEqual(try fixture.validated(fixture.incoming).version, fixture.candidateVersion)+ XCTAssertEqual(try fixture.validated(fixture.backup).version, Fixture.installedVersion)+ try fixture.assertNoStage()+ }++ func testReleaseWithoutApprovedVersionIsRejectedBeforeAnyStagingOrBackup() throws {+ let fixture = try Fixture()+ defer { fixture.cleanup() }+ XCTAssertThrowsError(try fixture.prepare(expectedVersion: nil)) { error in+ XCTAssertEqual(error as? UpdateBundleValidator.ValidationError, .invalidExpectation)+ }+ try fixture.assertOriginalUnchanged()+ XCTAssertFalse(FileManager.default.fileExists(atPath: fixture.backup.path))+ try fixture.assertNoStage()+ XCTAssertFalse(FileManager.default.fileExists(atPath: fixture.lockURL.path))+ }++ func testCancelledTaskBeforePreparationDoesNotTouchOriginalStageOrBackup() async throws {+ let fixture = try Fixture()+ defer { fixture.cleanup() }+ let gate = StartGate()+ let operation = Task.detached {+ await gate.wait()+ return try fixture.prepare()+ }+ operation.cancel()+ await gate.open()+ do {+ let installation = try await operation.value+ try installation.replacement.recover()+ XCTFail("Cancellation must reject preparation before exchange.")+ } catch is CancellationError {+ // This is the real production Task.checkCancellation exit.+ }+ try fixture.assertOriginalUnchanged()+ XCTAssertFalse(FileManager.default.fileExists(atPath: fixture.backup.path))+ try fixture.assertNoStage()+ XCTAssertFalse(FileManager.default.fileExists(atPath: fixture.lockURL.path))+ }++ private func assertInstalledChanged(_ error: Error) {+ guard let failure = error as? UpdateAppReplacement.Failure else { return XCTFail("Expected preparation wrapper: \(error)") }+ XCTAssertEqual(failure.operation, .preparation)+ guard case .installedAppChanged? = failure.underlyingError as? SimpleUpdateError else {+ return XCTFail("Expected installed app changed rejection: \(failure.underlyingError)")+ }+ }++ private actor StartGate {+ private var opened = false+ private var continuation: CheckedContinuation<Void, Never>?++ func wait() async {+ guard !self.opened else { return }+ await withCheckedContinuation { self.continuation = $0 }+ }++ func open() {+ self.opened = true+ self.continuation?.resume()+ self.continuation = nil+ }+ }++ private struct Fixture: Sendable {+ static let identifier = "com.fluidvoice.update-pipeline.fixture"+ static let installedVersion = "1.6.10-beta.7"+ static let installedBuild = "26"+ static let incomingVersion = "1.6.10-beta.8"+ static let approvedTeams: Set<String> = ["V4J43B279J", "537RRRT57V"]++ let root: URL+ let installed: URL+ let incoming: URL+ let backup: URL+ let candidateVersion: String+ var lockURL: URL { self.installed.deletingLastPathComponent().appendingPathComponent(".fluidvoice-update-\(self.installed.lastPathComponent).lock") }++ init(incomingDeveloperID: Bool = true, candidateVersion: String = Self.incomingVersion) throws {+ self.root = FileManager.default.temporaryDirectory.appendingPathComponent("UpdateInstallationPipelineTests-" + UUID().uuidString, isDirectory: true)+ self.installed = self.root.appendingPathComponent("Applications/Fixture.app")+ self.incoming = self.root.appendingPathComponent("Downloads/Incoming.app")+ self.backup = self.root.appendingPathComponent("Backups/Previous.app")+ self.candidateVersion = candidateVersion+ do {+ try self.makeBundle(at: self.installed, version: Self.installedVersion, build: Self.installedBuild, payload: "installed", developerID: false)+ try self.makeBundle(at: self.incoming, version: candidateVersion, build: "27", payload: "incoming", developerID: incomingDeveloperID)+ } catch {+ self.cleanup()+ throw error+ }+ }++ func cleanup() { try? FileManager.default.removeItem(at: self.root) }++ func prepare(+ installedVersion: String = Self.installedVersion,+ installedBuild: String = Self.installedBuild,+ expectedVersion: String? = Self.incomingVersion,+ isRollback: Bool = false+ ) throws -> SimpleUpdater.PreparedInstallation {+ try SimpleUpdater.prepareValidatedInstallation(+ installedAppURL: self.installed,+ downloadedAppURL: self.incoming,+ installedExpectation: .init(bundleIdentifier: Self.identifier, version: installedVersion, build: installedBuild),+ expectedVersion: expectedVersion,+ backupURL: self.backup,+ isRollback: isRollback+ )+ }++ func validated(_ bundle: URL) throws -> UpdateBundleValidator.ValidatedBundle {+ try UpdateBundleValidator.validate(+ at: bundle,+ expectation: .init(bundleIdentifier: Self.identifier, version: nil),+ policy: .installedApp(allowedTeamIDs: Self.approvedTeams)+ )+ }++ func payload(_ bundle: URL) throws -> String {+ try String(contentsOf: bundle.appendingPathComponent("Contents/Resources/payload.txt"), encoding: .utf8)+ }++ func assertOriginalUnchanged() throws {+ let original = try self.validated(self.installed)+ XCTAssertEqual(original.version, Self.installedVersion)+ XCTAssertEqual(original.build, Self.installedBuild)+ XCTAssertEqual(try self.payload(self.installed), "installed")+ }++ func assertNoStage() throws {+ let contents = try FileManager.default.contentsOfDirectory(atPath: self.installed.deletingLastPathComponent().path)+ XCTAssertFalse(contents.contains { $0.hasSuffix(".staging") })+ }++ private func makeBundle(at bundle: URL, version: String, build: String, payload: String, developerID: Bool) throws {+ let executableDirectory = bundle.appendingPathComponent("Contents/MacOS", isDirectory: true)+ let resources = bundle.appendingPathComponent("Contents/Resources", isDirectory: true)+ try FileManager.default.createDirectory(at: executableDirectory, withIntermediateDirectories: true)+ try FileManager.default.createDirectory(at: resources, withIntermediateDirectories: true)+ try FileManager.default.copyItem(at: URL(fileURLWithPath: "/usr/bin/true"), to: executableDirectory.appendingPathComponent("Fixture"))+ try Data(payload.utf8).write(to: resources.appendingPathComponent("payload.txt"))+ let plist = [+ "CFBundleIdentifier": Self.identifier,+ "CFBundleShortVersionString": version,+ "CFBundleVersion": build,+ "CFBundleExecutable": "Fixture",+ "CFBundlePackageType": "APPL",+ ]+ try PropertyListSerialization.data(fromPropertyList: plist, format: .xml, options: 0)+ .write(to: bundle.appendingPathComponent("Contents/Info.plist"))+ try self.sign(bundle, identity: self.signingIdentity(developerID: developerID))+ _ = try self.validated(bundle)+ }++ private func signingIdentity(developerID: Bool) throws -> String {+ let prefix = developerID ? "Developer ID Application:" : "Apple Development:"+ var result: CFTypeRef?+ let query: [String: Any] = [kSecClass as String: kSecClassIdentity, kSecReturnRef as String: true, kSecMatchLimit as String: kSecMatchLimitAll]+ let status = SecItemCopyMatching(query as CFDictionary, &result)+ guard status == errSecSuccess, let identities = result as? [SecIdentity] else {+ throw XCTSkip("A \(prefix) signing identity is required for signed pipeline fixtures.")+ }+ for identity in identities {+ var certificate: SecCertificate?+ guard SecIdentityCopyCertificate(identity, &certificate) == errSecSuccess, let certificate,+ let summary = SecCertificateCopySubjectSummary(certificate) as String?, summary.hasPrefix(prefix)+ else { continue }+ var trust: SecTrust?+ guard let policy = SecPolicyCreateWithProperties(kSecPolicyAppleCodeSigning, nil),+ SecTrustCreateWithCertificates(certificate, policy, &trust) == errSecSuccess, let trust,+ SecTrustSetNetworkFetchAllowed(trust, false) == errSecSuccess,+ SecTrustEvaluateWithError(trust, nil)+ else { continue }+ return Insecure.SHA1.hash(data: SecCertificateCopyData(certificate) as Data).map { String(format: "%02x", $0) }.joined()+ }+ throw XCTSkip("A valid \(prefix) signing identity is required for signed pipeline fixtures.")+ }++ private func sign(_ bundle: URL, identity: String) throws {+ let log = bundle.deletingLastPathComponent().appendingPathComponent(UUID().uuidString + ".codesign.log")+ XCTAssertTrue(FileManager.default.createFile(atPath: log.path, contents: nil))+ let output = try FileHandle(forWritingTo: log)+ defer { try? output.close() }+ let process = Process()+ process.executableURL = URL(fileURLWithPath: "/usr/bin/codesign")+ process.arguments = ["--force", "--sign", identity, "--timestamp=none", bundle.path]+ process.standardOutput = output+ process.standardError = output+ try process.run()+ let deadline = Date().addingTimeInterval(15)+ while process.isRunning, Date() < deadline {+ Thread.sleep(forTimeInterval: 0.01)+ }+ if process.isRunning {+ process.terminate()+ let terminationDeadline = Date().addingTimeInterval(1)+ while process.isRunning, Date() < terminationDeadline {+ Thread.sleep(forTimeInterval: 0.01)+ }+ if process.isRunning { kill(process.processIdentifier, SIGKILL) }+ XCTFail("Temporary fixture signing exceeded its bounded timeout.")+ throw NSError(domain: "UpdateInstallationPipelineTests", code: 1)+ }+ guard process.terminationStatus == 0 else {+ let diagnostic = (try? String(contentsOf: log, encoding: .utf8)) ?? "No signing diagnostic"+ XCTFail("Temporary fixture signing failed: \(diagnostic)")+ throw NSError(domain: "UpdateInstallationPipelineTests", code: Int(process.terminationStatus))+ }+ }+ }+}diff --git a/Tests/FluidDictationIntegrationTests/UpdateRollbackBackupTests.swift b/Tests/FluidDictationIntegrationTests/UpdateRollbackBackupTests.swiftnew file mode 100644index 00000000..f2fc331d--- /dev/null+++ b/Tests/FluidDictationIntegrationTests/UpdateRollbackBackupTests.swift@@ -0,0 +1,198 @@+@testable import FluidVoice_Debug+import Foundation+import XCTest++final nonisolated class UpdateRollbackBackupTests: XCTestCase {+ func testCopiesVerifiedBundleAndPreservesInstalledSource() throws {+ try self.withFixture { fixture in+ try fixture.create()+ XCTAssertEqual(try fixture.contents(fixture.installed), "old")+ XCTAssertEqual(try fixture.contents(fixture.backup), "old")+ XCTAssertFalse(fixture.stageExists)+ }+ }++ func testExistingBackupIsNeverOverwritten() throws {+ try self.withFixture { fixture in+ try fixture.makeBundle(at: fixture.backup, contents: "unrelated")+ XCTAssertThrowsError(try fixture.create())+ XCTAssertEqual(try fixture.contents(fixture.backup), "unrelated")+ XCTAssertEqual(try fixture.contents(fixture.installed), "old")+ XCTAssertFalse(fixture.stageExists)+ }+ }++ func testPartialCopyFailureCleansStagingWithoutPublishing() throws {+ try self.withFixture { fixture in+ var operations = UpdateRollbackBackup.Operations.live+ operations.copyBundle = { _, destination in+ try FileManager.default.createDirectory(at: destination, withIntermediateDirectories: false)+ try Data("partial".utf8).write(to: destination.appendingPathComponent("payload"))+ throw ProbeFailure.injected+ }+ XCTAssertThrowsError(try fixture.create(operations: operations))+ XCTAssertFalse(fixture.stageExists)+ XCTAssertFalse(FileManager.default.fileExists(atPath: fixture.backup.path))+ XCTAssertEqual(try fixture.contents(fixture.installed), "old")+ }+ }++ func testStagedValidationFailureCleansPartialAndDoesNotPublish() throws {+ try self.withFixture { fixture in+ XCTAssertThrowsError(try UpdateRollbackBackup.create(installedAppURL: fixture.installed, backupURL: fixture.backup, validate: { url in+ if url != fixture.installed { throw ProbeFailure.injected }+ }))+ XCTAssertFalse(fixture.stageExists)+ XCTAssertFalse(FileManager.default.fileExists(atPath: fixture.backup.path))+ XCTAssertEqual(try fixture.contents(fixture.installed), "old")+ }+ }++ func testCleanupFailureReportsOneStablePathAndNextAttemptRetriesIt() throws {+ try self.withFixture { fixture in+ var operations = UpdateRollbackBackup.Operations.live+ operations.copyBundle = { _, _ in throw ProbeFailure.injected }+ operations.removeDirectory = { _ in throw ProbeFailure.injected }+ for _ in 0..<2 {+ XCTAssertThrowsError(try fixture.create(operations: operations)) {+ XCTAssertEqual(($0 as? UpdateRollbackBackup.Failure)?.retainedDirectoryURL, fixture.stage)+ }+ XCTAssertEqual(try FileManager.default.contentsOfDirectory(atPath: fixture.root.path).filter { $0.hasSuffix(".staging") }, [fixture.stage.lastPathComponent])+ }+ try fixture.create()+ XCTAssertFalse(fixture.stageExists)+ XCTAssertEqual(try fixture.contents(fixture.backup), "old")+ }+ }++ func testOwnedCrashStageIsDiscardedOnlyAfterInstalledValidation() throws {+ try self.withFixture { fixture in+ try fixture.makeOwnedStage()+ try fixture.makeBundle(at: fixture.stage.appendingPathComponent("partial.app"), contents: "partial")+ XCTAssertThrowsError(try UpdateRollbackBackup.create(installedAppURL: fixture.installed, backupURL: fixture.backup, validate: { _ in throw ProbeFailure.injected }))+ XCTAssertTrue(fixture.stageExists)+ XCTAssertFalse(FileManager.default.fileExists(atPath: fixture.backup.path))+ try fixture.create()+ XCTAssertFalse(fixture.stageExists)+ XCTAssertEqual(try fixture.contents(fixture.backup), "old")+ }+ }++ func testUnknownStageAndForeignOwnershipArePreserved() throws {+ try self.withFixture { fixture in+ try FileManager.default.createDirectory(at: fixture.stage, withIntermediateDirectories: false)+ let marker = fixture.stage.appendingPathComponent("ownership")+ XCTAssertThrowsError(try fixture.create())+ XCTAssertTrue(fixture.stageExists)+ try Data("belongs to another app".utf8).write(to: marker)+ XCTAssertThrowsError(try fixture.create())+ XCTAssertEqual(try String(contentsOf: marker, encoding: .utf8), "belongs to another app")+ XCTAssertFalse(FileManager.default.fileExists(atPath: fixture.backup.path))+ }+ }++ func testSymlinkStageAndSymlinkMarkerCannotDeleteUnrelatedPaths() throws {+ try self.withFixture { fixture in+ let unrelated = fixture.root.appendingPathComponent("unrelated", isDirectory: true)+ try FileManager.default.createDirectory(at: unrelated, withIntermediateDirectories: false)+ try Data("preserve".utf8).write(to: unrelated.appendingPathComponent("payload"))+ let unrelatedMarker = unrelated.appendingPathComponent("ownership")+ try Data("FluidVoiceRollbackBackup-v1\n\(fixture.installed.standardizedFileURL.path)\n".utf8).write(to: unrelatedMarker)+ try FileManager.default.createSymbolicLink(at: fixture.stage, withDestinationURL: unrelated)+ XCTAssertThrowsError(try fixture.create())+ XCTAssertEqual(try fixture.contents(unrelated), "preserve")+ try FileManager.default.removeItem(at: fixture.stage)+ try FileManager.default.createDirectory(at: fixture.stage, withIntermediateDirectories: false)+ try FileManager.default.createSymbolicLink(at: fixture.stage.appendingPathComponent("ownership"), withDestinationURL: unrelatedMarker)+ XCTAssertThrowsError(try fixture.create())+ XCTAssertEqual(try fixture.contents(unrelated), "preserve")+ }+ }++ func testPublicationFailureCleansStagingAndPreservesSource() throws {+ try self.withFixture { fixture in+ var operations = UpdateRollbackBackup.Operations.live+ operations.publishBundle = { _, _ in throw ProbeFailure.injected }+ XCTAssertThrowsError(try fixture.create(operations: operations))+ XCTAssertFalse(fixture.stageExists)+ XCTAssertFalse(FileManager.default.fileExists(atPath: fixture.backup.path))+ XCTAssertEqual(try fixture.contents(fixture.installed), "old")+ }+ }++ func testCleanupFailureAfterPublicationRetainsVerifiedBackupAndRetries() throws {+ try self.withFixture { fixture in+ var operations = UpdateRollbackBackup.Operations.live+ operations.removeDirectory = { _ in throw ProbeFailure.injected }+ XCTAssertThrowsError(try fixture.create(operations: operations)) {+ XCTAssertEqual(($0 as? UpdateRollbackBackup.Failure)?.retainedDirectoryURL, fixture.stage)+ }+ XCTAssertEqual(try fixture.contents(fixture.backup), "old")+ XCTAssertEqual(try fixture.contents(fixture.installed), "old")+ let nextBackup = fixture.root.appendingPathComponent("next.app")+ try UpdateRollbackBackup.create(installedAppURL: fixture.installed, backupURL: nextBackup, validate: { try fixture.validate($0) })+ XCTAssertFalse(fixture.stageExists)+ XCTAssertEqual(try fixture.contents(nextBackup), "old")+ XCTAssertEqual(try fixture.contents(fixture.backup), "old")+ }+ }++ func testCreateFailureCannotDeleteAnUnknownPath() throws {+ try self.withFixture { fixture in+ var operations = UpdateRollbackBackup.Operations.live+ operations.createDirectory = { _ in throw ProbeFailure.injected }+ operations.removeDirectory = { _ in XCTFail("No owned directory was created") }+ XCTAssertThrowsError(try fixture.create(operations: operations))+ XCTAssertFalse(fixture.stageExists)+ XCTAssertEqual(try fixture.contents(fixture.installed), "old")+ }+ }++ private func withFixture(_ body: (Fixture) throws -> Void) throws {+ let fixture = try Fixture()+ defer { try? FileManager.default.removeItem(at: fixture.base) }+ try body(fixture)+ }++ private enum ProbeFailure: Error { case injected }++ private struct Fixture: Sendable {+ let base: URL+ let root: URL+ let installed: URL+ let backup: URL+ var stage: URL { self.root.appendingPathComponent(".fluidvoice-backup-FluidVoice.app.staging", isDirectory: true) }+ var stageExists: Bool { FileManager.default.fileExists(atPath: self.stage.path) }++ init() throws {+ self.base = FileManager.default.temporaryDirectory.appendingPathComponent("UpdateRollbackBackupTests-" + UUID().uuidString, isDirectory: true)+ self.root = self.base.appendingPathComponent("backups", isDirectory: true)+ self.installed = self.base.appendingPathComponent("FluidVoice.app", isDirectory: true)+ self.backup = self.root.appendingPathComponent("saved.app", isDirectory: true)+ try FileManager.default.createDirectory(at: self.root, withIntermediateDirectories: true)+ try self.makeBundle(at: self.installed, contents: "old")+ }++ func makeBundle(at url: URL, contents: String) throws {+ try FileManager.default.createDirectory(at: url, withIntermediateDirectories: false)+ try Data(contents.utf8).write(to: url.appendingPathComponent("payload"))+ }++ func contents(_ url: URL) throws -> String {+ try String(contentsOf: url.appendingPathComponent("payload"), encoding: .utf8)+ }++ func validate(_ url: URL) throws {+ guard try self.contents(url) == "old" else { throw ProbeFailure.injected }+ }++ func create(operations: UpdateRollbackBackup.Operations = .live) throws {+ try UpdateRollbackBackup.create(installedAppURL: self.installed, backupURL: self.backup, validate: { try self.validate($0) }, operations: operations)+ }++ func makeOwnedStage() throws {+ try FileManager.default.createDirectory(at: self.stage, withIntermediateDirectories: false)+ try Data("FluidVoiceRollbackBackup-v1\n\(self.installed.standardizedFileURL.path)\n".utf8).write(to: self.stage.appendingPathComponent("ownership"))+ }+ }+}diff --git a/Tests/FluidDictationIntegrationTests/VoiceModelDeletionTests.swift b/Tests/FluidDictationIntegrationTests/VoiceModelDeletionTests.swiftindex 406b9b85..08f05ac3 100644--- a/Tests/FluidDictationIntegrationTests/VoiceModelDeletionTests.swift+++ b/Tests/FluidDictationIntegrationTests/VoiceModelDeletionTests.swift@@ -1,5 +1,7 @@+import AppKit@testable import FluidVoice_Debugimport Foundation+import SwiftUIimport XCTest@MainActor@@ -9,11 +11,14 @@ private final class DeletionFixtureProvider: TranscriptionProvider {var isReady = truevar clearCalls = 0var prepareCalls = 0+ var cachedFilesExist = falsevar clear: (() async throws -> Void)?var prepareBody: (() async throws -> Void)?+ var preparationProgressHandler: ((ModelPreparationProgress) -> Void)?func prepare(progressHandler: ((ModelPreparationProgress) -> Void)?) async throws {self.prepareCalls += 1+ self.preparationProgressHandler = progressHandlertry await self.prepareBody?()}@@ -21,6 +26,8 @@ private final class DeletionFixtureProvider: TranscriptionProvider {ASRTranscriptionResult(text: "", confidence: 0)}+ func modelsExistOnDisk() -> Bool { self.cachedFilesExist }+func clearCache() async throws {self.clearCalls += 1try await self.clear?()@@ -30,6 +37,625 @@ private final class DeletionFixtureProvider: TranscriptionProvider {@MainActorfinal class VoiceModelDeletionTests: XCTestCase {+ private func makeNoHardwareController(for asr: ASRService) -> DirectCoreAudioLifecycleController {+ DirectCoreAudioLifecycleController(+ packetHandler: asr.recoveryPacketHandlerForTesting,+ inputFactory: { _, _ in throw CocoaError(.fileReadUnknown) },+ fingerprintReader: { _ in throw CocoaError(.fileReadUnknown) },+ installsHardwareListeners: false,+ deviceSnapshotReader: { _ in throw CocoaError(.fileReadUnknown) },+ deviceLivenessReader: { _ in nil },+ deviceResolver: { _ in throw CocoaError(.fileReadUnknown) },+ onFormatInvalidated: { _ in }+ )+ }++ private func withDictationModeSwitchFixture(+ asr: ASRService,+ hasActiveMode: Bool = true,+ body: (ContentView) async throws -> Void+ ) async throws {+ var ready: ContentView?+ let oldMode = NotchContentState.shared.mode+ let oldSlot = NotchContentState.shared.activeDictationShortcutSlot+ let oldPrompt = NotchContentState.shared.isPromptModeActive+ let oldProfileName = NotchContentState.shared.promptModeOverrideProfileName+ let oldProfileID = NotchContentState.shared.promptModeOverrideProfileID+ let oldStopLabel = NotchContentState.shared.stopSnapshotLabel+ let manager = MenuBarManager()+ let view = ContentView.dictationModeSwitchFixture(asr: asr, hasActiveMode: hasActiveMode) { ready = $0 }+ .environmentObject(manager)+ let host = NSHostingView(rootView: view)+ host.frame = NSRect(x: 0, y: 0, width: 120, height: 80)+ let window = NSWindow(contentRect: host.frame, styleMask: [.titled], backing: .buffered, defer: false)+ window.isReleasedWhenClosed = false+ window.contentView = host+ window.orderFront(nil)+ defer {+ window.orderOut(nil)+ window.contentView = nil+ window.close()+ NotchContentState.shared.mode = oldMode+ NotchContentState.shared.activeDictationShortcutSlot = oldSlot+ NotchContentState.shared.isPromptModeActive = oldPrompt+ NotchContentState.shared.promptModeOverrideProfileName = oldProfileName+ NotchContentState.shared.promptModeOverrideProfileID = oldProfileID+ NotchContentState.shared.stopSnapshotLabel = oldStopLabel+ }+ host.layoutSubtreeIfNeeded()+ let deadline = ContinuousClock.now + .seconds(3)+ while ready == nil, ContinuousClock.now < deadline {+ try await Task.sleep(for: .milliseconds(1))+ }+ manager.setOverlayMode(.edit)+ try await body(XCTUnwrap(ready, "SwiftUI must install the real ContentView state"))+ }++ private func replayPrimaryTap(_ manager: GlobalHotkeyManager) throws {+ for type in [CGEventType.keyDown, .keyUp] {+ let event = try XCTUnwrap(CGEvent(keyboardEventSource: nil, virtualKey: 2, keyDown: type == .keyDown))+ event.type = type+ event.flags = [.maskControl, .maskCommand]+ _ = manager.handleKeyEvent(type: type, event: event)+ }+ }++ private func makeModeSwitchHotkeyManager(+ asr: ASRService,+ view: ContentView,+ onSwitch: @escaping () -> Void,+ onStop: @escaping () -> Void+ ) -> GlobalHotkeyManager {+ let manager = GlobalHotkeyManager(+ asrService: asr,+ primaryShortcuts: [HotkeyShortcut(keyCode: 2, modifierFlags: [.control, .command])],+ promptModeShortcut: HotkeyShortcut(keyCode: 60, modifierFlags: []),+ commandModeShortcut: nil,+ rewriteModeShortcut: HotkeyShortcut(keyCode: 58, modifierFlags: []),+ promptModeShortcutEnabled: false,+ commandModeShortcutEnabled: false,+ rewriteModeShortcutEnabled: false,+ dictationModeCallback: {+ onSwitch()+ await view.beginDictationModeSwitchForTesting()?.value+ },+ stopAndProcessCallback: { _ in onStop() },+ isDictateRecordingProvider: { view.dictationModeSwitchStateForTesting.mode == "dictate" },+ isSessionLockedProvider: { false }+ )+ manager.setHotkeyMode(.toggle)+ return manager+ }++ func testRewriteToDictateSwitchPreservesCaptureThenNextTapStops() async throws {+ let settings = SettingsStore.shared+ let selected = settings.selectedSpeechModel+ let primary = settings.dictationPromptSelection(for: .primary)+ let secondary = settings.dictationPromptSelection(for: .secondary)+ let savesHistory = settings.saveTranscriptionHistory+ let asr = ASRService()+ let provider = DeletionFixtureProvider()+ asr.modelProvidersForTesting[selected] = provider+ asr.isAsrReady = true+ asr.finalText = "retained final text"+ let samples: [Float] = [0.12, -0.24, 0.31]+ asr.configureAudioRouteRecoveryForTesting(controller: self.makeNoHardwareController(for: asr), devices: [], initialSamples: samples)+ let lease = try asr.acquireExclusiveActivity(.dictation)+ asr.configureDictationModeSwitchForTesting(ownedLease: lease)+ try await self.withDictationModeSwitchFixture(asr: asr) { view in+ let generation = view.dictationModeSwitchStateForTesting.generation+ var switches = 0+ var stops = 0+ let manager = self.makeModeSwitchHotkeyManager(asr: asr, view: view, onSwitch: { switches += 1 }, onStop: {+ stops += 1+ asr.isRunning = false+ asr.releaseExclusiveActivity(lease)+ })+ asr.errorTitle = "Dictation Unavailable"+ asr.errorMessage = "Wait for the active dictation to finish."+ asr.showError = true+ try self.replayPrimaryTap(manager)+ for _ in 0..<20 {+ await Task.yield()+ }+ XCTAssertEqual(switches, 1)+ XCTAssertEqual(stops, 0)+ XCTAssertEqual(view.dictationModeSwitchStateForTesting.mode, "dictate")+ XCTAssertEqual(view.dictationModeSwitchStateForTesting.slot, .primary)+ XCTAssertEqual(view.dictationModeSwitchStateForTesting.generation, generation)+ XCTAssertEqual(NotchContentState.shared.mode, .dictation)+ XCTAssertFalse(asr.showError, "Only the stale own-capture block should disappear")+ XCTAssertTrue(asr.isRunning)+ XCTAssertTrue(asr.canSwitchOwnedDictationCaptureMode)+ XCTAssertEqual(asr.activeExclusiveActivity, .dictation)+ XCTAssertTrue(asr.audioRouteRecoveryStateForTesting.acceptingPCM)+ XCTAssertEqual(asr.audioRouteRecoveryStateForTesting.samples, samples)+ XCTAssertTrue((asr.fileTranscriptionProvider as? DeletionFixtureProvider) === provider)+ XCTAssertTrue(asr.isAsrReady)+ XCTAssertEqual(asr.finalText, "retained final text")+ XCTAssertEqual(provider.prepareCalls + provider.clearCalls, 0)+ XCTAssertEqual(settings.selectedSpeechModel, selected)+ XCTAssertEqual(settings.dictationPromptSelection(for: .primary), primary)+ XCTAssertEqual(settings.dictationPromptSelection(for: .secondary), secondary)+ XCTAssertEqual(settings.saveTranscriptionHistory, savesHistory)+ try self.replayPrimaryTap(manager)+ for _ in 0..<20 {+ await Task.yield()+ }+ XCTAssertEqual(switches, 1, "The next tap must stop, not switch again")+ XCTAssertEqual(stops, 1)+ XCTAssertFalse(asr.isRunning)+ XCTAssertNil(asr.activeExclusiveActivity)+ }+ asr.configureDictationModeSwitchForTesting(ownedLease: nil)+ await asr.finishAudioRouteRecoveryTest()+ asr.releaseExclusiveActivity(lease)+ }++ func testRapidRewriteToDictateDoubleTapSwitchesThenStopsOnce() async throws {+ let asr = ASRService()+ asr.configureAudioRouteRecoveryForTesting(controller: self.makeNoHardwareController(for: asr), devices: [], initialSamples: [0.5])+ let lease = try asr.acquireExclusiveActivity(.dictation)+ asr.configureDictationModeSwitchForTesting(ownedLease: lease)+ try await self.withDictationModeSwitchFixture(asr: asr) { view in+ var switches = 0+ var stops = 0+ let manager = self.makeModeSwitchHotkeyManager(asr: asr, view: view, onSwitch: { switches += 1 }, onStop: {+ stops += 1+ asr.isRunning = false+ asr.releaseExclusiveActivity(lease)+ })+ try self.replayPrimaryTap(manager)+ try self.replayPrimaryTap(manager)+ for _ in 0..<30 {+ await Task.yield()+ }+ XCTAssertEqual(switches, 1)+ XCTAssertEqual(stops, 1)+ XCTAssertEqual(view.dictationModeSwitchStateForTesting.mode, "dictate")+ XCTAssertEqual(asr.audioRouteRecoveryStateForTesting.samples, [0.5])+ }+ asr.configureDictationModeSwitchForTesting(ownedLease: nil)+ await asr.finishAudioRouteRecoveryTest()+ asr.releaseExclusiveActivity(lease)+ }++ func testDictationModeSwitchRejectsForeignAndUnsettledCaptureWithoutWrites() async throws {+ let cases: [(String, ASRExclusiveActivity)] = [+ ("meeting", .meeting), ("file", .fileTranscription), ("API", .localAPI),+ ("model", .modelMaintenance), ("backup", .settingsRestore),+ ("unowned", .dictation), ("mismatch", .dictation), ("stale", .dictation),+ ("starting", .dictation), ("finalizing", .dictation), ("training", .dictation),+ ("draining", .dictation), ("recovering", .dictation),+ ("idle UI", .dictation), ("cancel save", .dictation), ("processing", .dictation),+ ]+ let settings = SettingsStore.shared+ let secondary = settings.dictationPromptSelection(for: .secondary)+ defer { settings.setDictationPromptSelection(secondary, for: .secondary) }+ let attempted: SettingsStore.DictationPromptSelection = secondary == .privateAI ? .off : .privateAI+ for (name, activity) in cases {+ let asr = ASRService()+ let provider = DeletionFixtureProvider()+ asr.modelProvidersForTesting[settings.selectedSpeechModel] = provider+ asr.isAsrReady = true+ asr.configureAudioRouteRecoveryForTesting(controller: self.makeNoHardwareController(for: asr), devices: [], initialSamples: [0.25])+ let lease = try asr.acquireExclusiveActivity(activity)+ let owned = name == "unowned" ? nil : name == "mismatch" ? ASRActivityLease(id: UUID(), activity: .dictation) : lease+ asr.configureDictationModeSwitchForTesting(ownedLease: owned, starting: name == "starting", finalizing: name == "finalizing", dictionaryTraining: name == "training")+ if name == "stale" { asr.releaseExclusiveActivity(lease) }+ let finishDrain = name == "draining" || name == "recovering" ? asr.beginDictationBufferDrainForTesting(recovering: name == "recovering") : nil+ try await self.withDictationModeSwitchFixture(asr: asr, hasActiveMode: name != "idle UI") { view in+ view.blockDictationModeSwitchForTesting(savingCancellation: name == "cancel save", processing: name == "processing")+ let before = view.dictationModeSwitchStateForTesting+ XCTAssertNil(view.beginDictationModeSwitchForTesting(selection: attempted), name)+ XCTAssertEqual(view.dictationModeSwitchStateForTesting.mode, before.mode, name)+ XCTAssertEqual(view.dictationModeSwitchStateForTesting.slot, before.slot, name)+ XCTAssertEqual(view.dictationModeSwitchStateForTesting.generation, before.generation, name)+ XCTAssertEqual(NotchContentState.shared.mode, .edit, name)+ XCTAssertEqual(settings.dictationPromptSelection(for: .secondary), secondary, name)+ XCTAssertEqual(asr.audioRouteRecoveryStateForTesting.samples, [0.25], name)+ XCTAssertTrue(asr.audioRouteRecoveryStateForTesting.acceptingPCM, name)+ XCTAssertTrue((asr.fileTranscriptionProvider as? DeletionFixtureProvider) === provider, name)+ XCTAssertEqual(provider.prepareCalls + provider.clearCalls, 0, name)+ }+ finishDrain?()+ asr.configureDictationModeSwitchForTesting(ownedLease: nil)+ await asr.finishAudioRouteRecoveryTest()+ asr.releaseExclusiveActivity(lease)+ }+ }++ func testOwnedDictationModeSwitchPreservesUnrelatedError() async throws {+ let asr = ASRService()+ asr.configureAudioRouteRecoveryForTesting(controller: self.makeNoHardwareController(for: asr), devices: [], initialSamples: [0.25])+ let lease = try asr.acquireExclusiveActivity(.dictation)+ asr.configureDictationModeSwitchForTesting(ownedLease: lease)+ asr.errorTitle = "Microphone Unavailable"+ asr.errorMessage = "Retained microphone error"+ asr.showError = true+ try await self.withDictationModeSwitchFixture(asr: asr) { view in+ XCTAssertNil(view.beginDictationModeSwitchForTesting())+ XCTAssertEqual(view.dictationModeSwitchStateForTesting.mode, "dictate")+ XCTAssertTrue(asr.showError)+ XCTAssertEqual(asr.errorTitle, "Microphone Unavailable")+ XCTAssertEqual(asr.errorMessage, "Retained microphone error")+ }+ asr.configureDictationModeSwitchForTesting(ownedLease: nil)+ await asr.finishAudioRouteRecoveryTest()+ asr.releaseExclusiveActivity(lease)+ }++ func testBusyBackupAdmissionPreservesCapturedPCMProviderAndActivity() async throws {+ let settings = SettingsStore.shared+ let previous = settings.selectedSpeechModel+ defer { settings.selectedSpeechModel = previous }+ settings.selectedSpeechModel = .appleSpeech+ let asr = ASRService()+ let original = DeletionFixtureProvider()+ let replacement = DeletionFixtureProvider()+ asr.modelProvidersForTesting[.appleSpeech] = original+ asr.modelProvidersForTesting[.parakeetTDT] = replacement+ asr.isAsrReady = true+ // Never open an input, query Core Audio, or install real hardware listeners.+ let controller = self.makeNoHardwareController(for: asr)+ let samples: [Float] = [0.12, -0.24, 0.31]+ asr.configureAudioRouteRecoveryForTesting(controller: controller, devices: [], initialSamples: samples)+ let dictation = try asr.acquireExclusiveActivity(.dictation)+ let before = asr.audioRouteRecoveryStateForTesting+ XCTAssertThrowsError(try asr.beginSettingsBackupRestore()) { error in+ guard case ASRActivityError.settingsRestoreUnavailable = error else { return XCTFail("Unexpected admission error: \(error)") }+ }+ XCTAssertEqual(settings.selectedSpeechModel, .appleSpeech)+ XCTAssertTrue((asr.fileTranscriptionProvider as? DeletionFixtureProvider) === original)+ XCTAssertTrue(asr.isAsrReady)+ XCTAssertEqual(asr.activeExclusiveActivity, .dictation)+ let after = asr.audioRouteRecoveryStateForTesting+ XCTAssertTrue(after.acceptingPCM)+ XCTAssertEqual(after.samples, samples)+ XCTAssertEqual(after.pending, before.pending)+ XCTAssertEqual(after.recovering, before.recovering)+ XCTAssertEqual(original.prepareCalls + replacement.prepareCalls, 0)+ XCTAssertEqual(original.clearCalls + replacement.clearCalls, 0)+ await asr.finishAudioRouteRecoveryTest()+ asr.releaseExclusiveActivity(dictation)+ let admitted = try asr.beginSettingsBackupRestore()+ XCTAssertEqual(asr.activeExclusiveActivity, .settingsRestore)+ asr.releaseExclusiveActivity(admitted)+ XCTAssertNil(asr.activeExclusiveActivity)+ }++ func testBackupReservationRejectsNewTranscriptionModelWorkAndPreview() async throws {+ let asr = ASRService()+ let selected = SettingsStore.shared.selectedSpeechModel+ let provider = DeletionFixtureProvider()+ asr.modelProvidersForTesting[selected] = provider+ asr.modelProvidersForTesting[.whisperTiny] = provider+ let reservation = try asr.beginSettingsBackupRestore()+ for activity: ASRExclusiveActivity in [.dictation, .fileTranscription, .localAPI, .meeting, .modelMaintenance] {+ XCTAssertThrowsError(try asr.acquireExclusiveActivity(activity))+ }+ do {+ try await asr.ensureAsrReady()+ XCTFail("Preparation must not enter while a backup is being applied")+ } catch let ASRActivityError.activityInProgress(activity) {+ XCTAssertEqual(activity, .settingsRestore)+ }+ do {+ try await asr.downloadModel(.whisperTiny, progressHandler: nil)+ XCTFail("Download must not enter while a backup is being applied")+ } catch let ASRActivityError.activityInProgress(activity) {+ XCTAssertEqual(activity, .settingsRestore)+ }+ do {+ try await asr.clearModelCache(for: .whisperTiny)+ XCTFail("Deletion must not enter while a backup is being applied")+ } catch {}+ asr.micStatus = .authorized+ await asr.startMicrophonePreview()+ XCTAssertFalse(asr.isMicrophonePreviewActive)+ XCTAssertFalse(asr.hasActiveModelDownload)+ XCTAssertFalse(asr.hasActiveModelPreparation)+ XCTAssertNil(asr.deletingModelID)+ XCTAssertEqual(provider.prepareCalls, 0)+ XCTAssertEqual(provider.clearCalls, 0)+ XCTAssertEqual(SettingsStore.shared.selectedSpeechModel, selected)+ XCTAssertEqual(asr.activeExclusiveActivity, .settingsRestore)+ asr.releaseExclusiveActivity(reservation)+ XCTAssertNil(asr.activeExclusiveActivity)+ let retry = try asr.beginSettingsBackupRestore()+ asr.releaseExclusiveActivity(retry)+ }++ func testSynchronousBackupResetPrecedesQueuedPostImportAdmission() async throws {+ let settings = SettingsStore.shared+ let previous = settings.selectedSpeechModel+ defer { settings.selectedSpeechModel = previous }+ settings.selectedSpeechModel = .parakeetTDT+ let asr = ASRService()+ asr.configureAudioRouteRecoveryForTesting(+ controller: self.makeNoHardwareController(for: asr), devices: [], initialSamples: []+ )+ await asr.finishAudioRouteRecoveryTest()+ // Provider construction is metadata-only; no preparation or model load.+ let retired = try XCTUnwrap(asr.fileTranscriptionProvider as? FluidAudioProvider)+ asr.isAsrReady = true+ let reservation = try asr.beginSettingsBackupRestore()+ settings.selectedSpeechModel = .parakeetTDTv2+ // Mirrors the unchanged-idle import tail: synchronous invalidation,+ // UI event/queued caller, then lease release, with no intervening await.+ asr.handleSettingsBackupDidRestore()+ XCTAssertTrue(asr.isAsrReady, "The held reservation defers retirement until release")+ XCTAssertEqual(asr.activeExclusiveActivity, .settingsRestore)+ let queuedCaller = Task { @MainActor in+ XCTAssertFalse(asr.isAsrReady, "A queued caller must never see old ready state after import admission releases")+ XCTAssertFalse((asr.fileTranscriptionProvider as? FluidAudioProvider) === retired, "The old cached provider must be retired before the caller runs")+ do {+ let next = try asr.acquireExclusiveActivity(.dictation)+ asr.releaseExclusiveActivity(next)+ } catch let ASRActivityError.activityInProgress(activity) {+ XCTAssertEqual(activity, .modelMaintenance, "The bounded model reset may still own admission")+ } catch { XCTFail("Unexpected queued admission error: \(error)") }+ }+ asr.releaseExclusiveActivity(reservation)+ XCTAssertFalse(asr.isAsrReady)+ XCTAssertFalse((asr.fileTranscriptionProvider as? FluidAudioProvider) === retired)+ // Cache-existence checks use a fake and never prepare/load actual models.+ let replacement = DeletionFixtureProvider()+ asr.modelProvidersForTesting[.parakeetTDTv2] = replacement+ await queuedCaller.value+ await asr.finishAudioRouteRecoveryTest()+ let deadline = ContinuousClock.now + .seconds(3)+ while asr.activeExclusiveActivity != nil, ContinuousClock.now < deadline {+ try await Task.sleep(for: .milliseconds(1))+ }+ XCTAssertNil(asr.activeExclusiveActivity)+ XCTAssertEqual(replacement.prepareCalls, 0)+ XCTAssertEqual(replacement.clearCalls, 0)+ let retry = try asr.beginSettingsBackupRestore()+ asr.releaseExclusiveActivity(retry)+ }++ func testActiveDownloadRejectsBackupWithoutCancellingOrChangingIt() async throws {+ let asr = ASRService()+ let selected = SettingsStore.shared.selectedSpeechModel+ let provider = DeletionFixtureProvider()+ asr.modelProvidersForTesting[.whisperTiny] = provider+ provider.prepareBody = {+ XCTAssertTrue(asr.hasActiveModelDownload)+ XCTAssertThrowsError(try asr.beginSettingsBackupRestore())+ XCTAssertNil(asr.activeExclusiveActivity)+ XCTAssertTrue(asr.hasActiveModelDownload)+ XCTAssertFalse(asr.isCancellingModelDownload)+ XCTAssertEqual(SettingsStore.shared.selectedSpeechModel, selected)+ }+ try await asr.downloadModel(.whisperTiny, progressHandler: nil)+ XCTAssertEqual(provider.prepareCalls, 1)+ XCTAssertEqual(provider.clearCalls, 0)+ provider.prepareBody = nil+ let retry = try asr.beginSettingsBackupRestore()+ asr.releaseExclusiveActivity(retry)+ }++ func testActivePreparationRejectsBackupWithoutCancellingIt() async throws {+ let settings = SettingsStore.shared+ let previous = settings.selectedSpeechModel+ defer { settings.selectedSpeechModel = previous }+ settings.selectedSpeechModel = .whisperTiny+ let asr = ASRService()+ let provider = DeletionFixtureProvider()+ asr.modelProvidersForTesting[.whisperTiny] = provider+ provider.prepareBody = {+ XCTAssertTrue(asr.hasActiveModelPreparation)+ XCTAssertThrowsError(try asr.beginSettingsBackupRestore())+ XCTAssertNil(asr.activeExclusiveActivity)+ XCTAssertTrue(asr.hasActiveModelPreparation)+ XCTAssertFalse(asr.isCancellingModelPreparation)+ throw CocoaError(.fileReadUnknown)+ }+ do { try await asr.ensureAsrReady() } catch {}+ XCTAssertEqual(provider.prepareCalls, 1)+ XCTAssertEqual(provider.clearCalls, 0)+ provider.prepareBody = nil+ let retry = try asr.beginSettingsBackupRestore()+ asr.releaseExclusiveActivity(retry)+ }++ func testCompletedProviderResetDoesNotPermanentlyBlockBackupImport() async throws {+ let settings = SettingsStore.shared+ let previous = settings.selectedSpeechModel+ defer { settings.selectedSpeechModel = previous }+ settings.selectedSpeechModel = .whisperTiny+ let asr = ASRService()+ let provider = DeletionFixtureProvider()+ asr.modelProvidersForTesting[.whisperTiny] = provider+ asr.resetTranscriptionProvider()+ XCTAssertThrowsError(try asr.beginSettingsBackupRestore())+ let deadline = ContinuousClock.now + .seconds(3)+ while asr.activeExclusiveActivity != nil, ContinuousClock.now < deadline {+ try await Task.sleep(for: .milliseconds(1))+ }+ XCTAssertNil(asr.activeExclusiveActivity)+ // Give the independent executor drain its actor turn; no ensureAsrReady+ // call is allowed to hide a stale completed reset handle in this regression.+ var reservation: ASRActivityLease?+ while reservation == nil, ContinuousClock.now < deadline {+ reservation = try? asr.beginSettingsBackupRestore()+ if reservation == nil { try await Task.sleep(for: .milliseconds(1)) }+ }+ let admitted = try XCTUnwrap(reservation)+ asr.releaseExclusiveActivity(admitted)+ XCTAssertEqual(provider.prepareCalls, 0)+ XCTAssertEqual(provider.clearCalls, 0)+ XCTAssertEqual(settings.selectedSpeechModel, .whisperTiny)+ }++ func testCancelledBackupAdmissionNeverAcquiresAnActivity() async throws {+ let asr = ASRService()+ let cancelled = Task { () throws -> ASRActivityLease in+ withUnsafeCurrentTask { $0?.cancel() }+ return try asr.beginSettingsBackupRestore()+ }+ do { _ = try await cancelled.value; XCTFail("Cancelled imports must not reserve activity") } catch is CancellationError {}+ XCTAssertNil(asr.activeExclusiveActivity)+ let retry = try asr.beginSettingsBackupRestore()+ asr.releaseExclusiveActivity(retry)+ }++ func testCancelledDownloadKeepsCleanupFailureAndDoesNotClearPublishedCache() async throws {+ let selected = SettingsStore.shared.selectedSpeechModel+ let retained = FileManager.default.temporaryDirectory.appendingPathComponent("retained-download-stage")+ let asr = ASRService()+ let provider = DeletionFixtureProvider()+ provider.cachedFilesExist = true+ provider.prepareBody = {+ withUnsafeCurrentTask { $0?.cancel() }+ throw ParakeetArchiveDownloader.DownloadError.cleanupFailed(retained)+ }+ asr.modelProvidersForTesting[.fluidParakeetMini] = provider+ do {+ try await asr.downloadModel(.fluidParakeetMini, progressHandler: nil)+ XCTFail("The retained cleanup path must reach the caller")+ } catch let error as ParakeetArchiveDownloader.DownloadError {+ guard case let .cleanupFailed(path) = error else { return XCTFail("Unexpected archive failure") }+ XCTAssertEqual(path, retained)+ }+ XCTAssertEqual(provider.clearCalls, 0)+ XCTAssertEqual(provider.prepareCalls, 1)+ XCTAssertEqual(SettingsStore.shared.selectedSpeechModel, selected)+ XCTAssertFalse(asr.hasActiveModelDownload)+ XCTAssertFalse(asr.isCancellingModelDownload)+ XCTAssertNil(asr.downloadingModelId)+ }++ func testPreparationCleanupFailureSkipsDestructiveRetryEvenWhenCancelled() async throws {+ guard SettingsStore.SpeechModel.availableModels.contains(.fluidParakeetMini) else {+ throw XCTSkip("Compact model preparation requires a supported Mac and macOS version")+ }+ let settings = SettingsStore.shared+ let previous = settings.selectedSpeechModel+ defer { settings.selectedSpeechModel = previous }+ settings.selectedSpeechModel = .fluidParakeetMini+ let retained = FileManager.default.temporaryDirectory.appendingPathComponent("retained-preparation-stage")+ for cancelled in [false, true] {+ for cached in [false, true] {+ let asr = ASRService()+ let provider = DeletionFixtureProvider()+ provider.cachedFilesExist = cached+ provider.prepareBody = {+ if cancelled { withUnsafeCurrentTask { $0?.cancel() } }+ throw ParakeetArchiveDownloader.DownloadError.cleanupFailed(retained)+ }+ asr.modelProvidersForTesting[.fluidParakeetMini] = provider+ do {+ try await asr.ensureAsrReady()+ XCTFail("The retained cleanup path must reach the caller")+ } catch let error as ParakeetArchiveDownloader.DownloadError {+ guard case let .cleanupFailed(path) = error else { return XCTFail("Unexpected archive failure") }+ XCTAssertEqual(path, retained)+ }+ XCTAssertEqual(provider.prepareCalls, 1)+ XCTAssertEqual(provider.clearCalls, 0, "A staging failure must preserve published model files")+ XCTAssertFalse(asr.isAsrReady)+ XCTAssertFalse(asr.hasActiveModelPreparation)+ XCTAssertFalse(asr.isCancellingModelPreparation)+ XCTAssertFalse(asr.isDownloadingModel)+ XCTAssertFalse(asr.isLoadingModel)+ }+ }+ }++ func testRestoredCompactSelectionRetiresReadyModelOnlyAfterActiveWorkFinishes() async throws {+ let settings = SettingsStore.shared+ let previous = settings.selectedSpeechModel+ defer { settings.selectedSpeechModel = previous }+ for model: SettingsStore.SpeechModel in [.fluidParakeetMini, .fluidParakeetPico] {+ settings.selectedSpeechModel = .parakeetTDT+ let asr = ASRService()+ let old = DeletionFixtureProvider()+ let restored = DeletionFixtureProvider()+ asr.modelProvidersForTesting[.parakeetTDT] = old+ asr.modelProvidersForTesting[model] = restored+ asr.isAsrReady = true+ let lease = try asr.acquireExclusiveActivity(.dictation)+ settings.selectedSpeechModel = model+ asr.handleSettingsBackupDidRestore()+ XCTAssertTrue(asr.isAsrReady, "Restoring settings must not interrupt active dictation")+ XCTAssertEqual(asr.activeExclusiveActivity, .dictation)+ XCTAssertEqual(old.clearCalls, 0)+ XCTAssertEqual(restored.prepareCalls, 0)+ await asr.finishAudioRouteRecoveryTest()+ asr.releaseExclusiveActivity(lease)+ XCTAssertFalse(asr.isAsrReady, "The old ready model must be retired before the next dictation")+ XCTAssertEqual(settings.selectedSpeechModel, model)+ XCTAssertEqual(old.clearCalls, 0, "Restoring settings must retain downloaded files")+ let deadline = Date().addingTimeInterval(2)+ while asr.activeExclusiveActivity != nil, Date() < deadline {+ try await Task.sleep(for: .milliseconds(1))+ }+ XCTAssertNil(asr.activeExclusiveActivity)+ }+ }++ func testCompactModelDownloadsKeepActiveSelectionAndRejectCompetingDeletion() async throws {+ let settings = SettingsStore.shared+ let previous = settings.selectedSpeechModel+ defer { settings.selectedSpeechModel = previous }+ settings.selectedSpeechModel = .parakeetTDT+ for model: SettingsStore.SpeechModel in [.fluidParakeetMini, .fluidParakeetPico] {+ let asr = ASRService()+ let target = DeletionFixtureProvider()+ let active = DeletionFixtureProvider()+ asr.isAsrReady = true+ asr.modelProvidersForTesting[model] = target+ asr.modelProvidersForTesting[.parakeetTDT] = active+ target.prepareBody = {+ XCTAssertEqual(asr.downloadingModelId, model.id)+ XCTAssertEqual(settings.selectedSpeechModel, .parakeetTDT)+ do {+ try await asr.clearModelCache(for: model)+ XCTFail("A model being downloaded must not be deleted")+ } catch {}+ XCTAssertTrue(asr.hasActiveModelDownload)+ }+ try await asr.downloadModel(model, progressHandler: nil)+ XCTAssertEqual(target.prepareCalls, 1)+ XCTAssertEqual(active.prepareCalls, 0)+ XCTAssertEqual(active.clearCalls, 0)+ XCTAssertTrue(active.isReady)+ XCTAssertTrue(asr.isAsrReady)+ XCTAssertEqual(settings.selectedSpeechModel, .parakeetTDT)+ XCTAssertFalse(asr.hasActiveModelDownload)+ XCTAssertNil(asr.downloadingModelId)+ target.prepareBody = nil+ }+ }++ func testCompactModelFailedAndCancelledDownloadsReleaseAdmission() async throws {+ let selected = SettingsStore.shared.selectedSpeechModel+ for model: SettingsStore.SpeechModel in [.fluidParakeetMini, .fluidParakeetPico] {+ let asr = ASRService()+ let provider = DeletionFixtureProvider()+ asr.modelProvidersForTesting[model] = provider+ for cancelled in [false, true] {+ provider.prepareBody = {+ if cancelled { throw CancellationError() }+ throw URLError(.notConnectedToInternet)+ }+ do {+ try await asr.downloadModel(model, progressHandler: nil)+ XCTFail("Failure must reach the caller")+ } catch {}+ XCTAssertEqual(SettingsStore.shared.selectedSpeechModel, selected)+ XCTAssertFalse(asr.hasActiveModelDownload)+ XCTAssertNil(asr.downloadingModelId)+ XCTAssertFalse(asr.isCancellingModelDownload)+ }+ provider.prepareBody = nil+ try await asr.downloadModel(model, progressHandler: nil)+ XCTAssertEqual(provider.prepareCalls, 3)+ }+ }+func testLegacyNemotronDeletionUsesCanonicalProviderAndInvalidatesOnlyActiveModel() async throws {let settings = SettingsStore.sharedlet previous = settings.selectedSpeechModel@@ -241,4 +867,217 @@ final class VoiceModelDeletionTests: XCTestCase {XCTAssertNil(asr.deletingModelID)XCTAssertNil(asr.activeExclusiveActivity)}++ func testCompactLoadCancellationRetainsAtomicallyPublishedModelsAndLegacyPolicy() {+ #if arch(arm64)+ for model: SettingsStore.SpeechModel in [.fluidParakeetMini, .fluidParakeetPico] {+ let provider = FluidAudioProvider(modelOverride: model, configureWordBoosting: false)+ XCTAssertFalse(+ provider.shouldClearCacheAfterCancellation,+ "The hosted downloader owns staging cleanup; cancellation during Core ML loading must retain a verified publication"+ )+ XCTAssertEqual(provider.modelsExistOnDisk(), SpeechModelInstallationSnapshot.shared.isInstalled(modelID: model.id))+ }+ for model: SettingsStore.SpeechModel in [.parakeetTDTv2, .parakeetTDT] {+ XCTAssertTrue(FluidAudioProvider(modelOverride: model, configureWordBoosting: false).shouldClearCacheAfterCancellation)+ }+ #endif+ }++ func testCompactWeightUpdatesRejectEveryForeignActivityWithoutChangingCaptureOrProvider() async throws {+ let selected = SettingsStore.shared.selectedSpeechModel+ for activity: ASRExclusiveActivity in [.dictation, .meeting, .fileTranscription, .localAPI, .settingsRestore, .modelMaintenance] {+ let asr = ASRService()+ let provider = DeletionFixtureProvider()+ asr.modelProvidersForTesting[.fluidParakeetMini] = provider+ asr.isAsrReady = true+ let lease = try asr.acquireExclusiveActivity(activity)+ do {+ try await asr.downloadModel(.fluidParakeetMini, updateWeights: true, progressHandler: nil)+ XCTFail("Updates must not enter while \(activity) owns admission")+ } catch {}+ XCTAssertEqual(asr.activeExclusiveActivity, activity)+ XCTAssertEqual(provider.prepareCalls + provider.clearCalls, 0)+ XCTAssertTrue(provider.isReady)+ XCTAssertTrue(asr.isAsrReady)+ XCTAssertFalse(asr.hasActiveModelDownload)+ XCTAssertEqual(SettingsStore.shared.selectedSpeechModel, selected)+ asr.releaseExclusiveActivity(lease)+ }+ }++ func testCompactWeightUpdatesRejectUnownedCaptureAndPendingDrains() async throws {+ for state in ["running", "starting", "finalizing", "training", "draining", "recovering"] {+ let asr = ASRService()+ let provider = DeletionFixtureProvider()+ asr.modelProvidersForTesting[.fluidParakeetMini] = provider+ asr.isAsrReady = true+ asr.isRunning = state == "running"+ asr.configureDictationModeSwitchForTesting(ownedLease: nil, starting: state == "starting", finalizing: state == "finalizing", dictionaryTraining: state == "training")+ let finish = state == "draining" || state == "recovering" ? asr.beginDictationBufferDrainForTesting(recovering: state == "recovering") : nil+ do {+ try await asr.downloadModel(.fluidParakeetMini, updateWeights: true, progressHandler: nil)+ XCTFail("Updates must not change \(state) audio")+ } catch {}+ XCTAssertEqual(provider.prepareCalls + provider.clearCalls, 0)+ XCTAssertEqual(asr.isRunning, state == "running")+ XCTAssertTrue(asr.isAsrReady)+ XCTAssertNil(asr.activeExclusiveActivity)+ XCTAssertFalse(asr.hasActiveModelDownload)+ finish?()+ asr.isRunning = false+ asr.configureDictationModeSwitchForTesting(ownedLease: nil)+ }+ }++ func testInactiveCompactWeightUpdateReservesAdmissionWithoutChangingActiveSelection() async throws {+ let settings = SettingsStore.shared+ let selected = settings.selectedSpeechModel+ defer { settings.selectedSpeechModel = selected }+ settings.selectedSpeechModel = .parakeetTDTv2+ for model: SettingsStore.SpeechModel in [.fluidParakeetMini, .fluidParakeetPico] {+ let asr = ASRService()+ let target = DeletionFixtureProvider()+ let active = DeletionFixtureProvider()+ asr.modelProvidersForTesting[model] = target+ asr.modelProvidersForTesting[.parakeetTDTv2] = active+ asr.isAsrReady = true+ target.prepareBody = {+ XCTAssertEqual(asr.activeExclusiveActivity, .modelMaintenance)+ XCTAssertTrue(asr.hasActiveModelDownload)+ XCTAssertThrowsError(try asr.acquireExclusiveActivity(.dictation))+ XCTAssertThrowsError(try asr.beginSettingsBackupRestore())+ do { try await asr.clearModelCache(for: model); XCTFail("A weight update must block deletion") } catch {}+ do { try await asr.downloadModel(.whisperTiny, progressHandler: nil); XCTFail("A weight update must block competing downloads") } catch {}+ }+ try await asr.downloadModel(model, updateWeights: true, progressHandler: nil)+ XCTAssertEqual(target.prepareCalls, 1)+ XCTAssertEqual(target.clearCalls, 0)+ XCTAssertEqual(active.prepareCalls + active.clearCalls, 0)+ XCTAssertTrue(active.isReady)+ XCTAssertTrue(asr.isAsrReady)+ XCTAssertEqual(settings.selectedSpeechModel, .parakeetTDTv2)+ XCTAssertNil(asr.activeExclusiveActivity)+ XCTAssertFalse(asr.hasActiveModelDownload)+ XCTAssertNil(asr.downloadingModelId)+ }+ }++ func testFailedOrCancelledWeightUpdateKeepsActiveProviderAndNeverClearsPublishedFiles() async throws {+ let settings = SettingsStore.shared+ let selected = settings.selectedSpeechModel+ defer { settings.selectedSpeechModel = selected }+ for model: SettingsStore.SpeechModel in [.fluidParakeetMini, .fluidParakeetPico] {+ settings.selectedSpeechModel = model+ for cancelled in [false, true] {+ let asr = ASRService()+ let provider = DeletionFixtureProvider()+ asr.modelProvidersForTesting[model] = provider+ asr.isAsrReady = true+ provider.prepareBody = {+ if cancelled { throw CancellationError() }+ throw URLError(.notConnectedToInternet)+ }+ do { try await asr.downloadModel(model, updateWeights: true, progressHandler: nil); XCTFail("Failure must reach the caller") } catch {}+ XCTAssertEqual(provider.prepareCalls, 1)+ XCTAssertEqual(provider.clearCalls, 0, "Explicit update failures never delete old files")+ XCTAssertTrue(provider.isReady)+ XCTAssertTrue(asr.isAsrReady)+ XCTAssertTrue((asr.fileTranscriptionProvider as? DeletionFixtureProvider) === provider)+ XCTAssertEqual(settings.selectedSpeechModel, model)+ XCTAssertNil(asr.activeExclusiveActivity)+ XCTAssertFalse(asr.hasActiveModelDownload)+ XCTAssertFalse(asr.isCancellingModelDownload)+ let retry = try asr.acquireExclusiveActivity(.dictation)+ asr.releaseExclusiveActivity(retry)+ }+ }+ }++ func testOnlyCompactModelsAcceptWeightUpdatesAndCancelledAdmissionHasNoWrites() async throws {+ let asr = ASRService()+ let provider = DeletionFixtureProvider()+ asr.modelProvidersForTesting[.parakeetTDTv2] = provider+ asr.modelProvidersForTesting[.fluidParakeetMini] = provider+ do { try await asr.downloadModel(.parakeetTDTv2, updateWeights: true, progressHandler: nil); XCTFail("Legacy models have no weight-update path") } catch {}+ let task = Task { try await asr.downloadModel(.fluidParakeetMini, updateWeights: true, progressHandler: nil) }+ task.cancel()+ do { try await task.value; XCTFail("Cancelled admission must not begin") } catch is CancellationError {}+ XCTAssertEqual(provider.prepareCalls + provider.clearCalls, 0)+ XCTAssertNil(asr.activeExclusiveActivity)+ XCTAssertFalse(asr.hasActiveModelDownload)+ }++ func testStaleCancelledWeightUpdateProgressCannotReplaceRetryProgress() async throws {+ let settings = SettingsStore.shared+ let selected = settings.selectedSpeechModel+ defer { settings.selectedSpeechModel = selected }+ settings.selectedSpeechModel = .parakeetTDTv2+ let asr = ASRService()+ let provider = DeletionFixtureProvider()+ asr.modelProvidersForTesting[.fluidParakeetMini] = provider+ provider.prepareBody = { throw CancellationError() }+ do { try await asr.downloadModel(.fluidParakeetMini, updateWeights: true, progressHandler: nil); XCTFail("First update cancels") } catch is CancellationError {}+ let stale = provider.preparationProgressHandler+ provider.prepareBody = {+ stale?(.downloading(0.97))+ for _ in 0..<4 {+ await Task.yield()+ }+ XCTAssertNil(asr.downloadProgress, "An old operation must not update the new progress")+ provider.preparationProgressHandler?(.downloading(0.25))+ for _ in 0..<4 {+ await Task.yield()+ }+ XCTAssertEqual(asr.downloadProgress, 0.25)+ }+ try await asr.downloadModel(.fluidParakeetMini, updateWeights: true, progressHandler: nil)+ XCTAssertNil(asr.downloadProgress)+ XCTAssertEqual(provider.clearCalls, 0)+ XCTAssertEqual(settings.selectedSpeechModel, .parakeetTDTv2)+ XCTAssertNil(asr.activeExclusiveActivity)+ }++ func testSuccessfulActiveWeightUpdateInvalidatesProviderOnlyAfterPublication() async throws {+ let settings = SettingsStore.shared+ let selected = settings.selectedSpeechModel+ defer { settings.selectedSpeechModel = selected }+ settings.selectedSpeechModel = .fluidParakeetMini+ let asr = ASRService()+ let provider = DeletionFixtureProvider()+ asr.modelProvidersForTesting[.fluidParakeetMini] = provider+ asr.isAsrReady = true+ provider.prepareBody = {+ XCTAssertTrue(asr.isAsrReady, "Keep the old checkpoint ready until replacement commits")+ XCTAssertEqual(asr.activeExclusiveActivity, .modelMaintenance)+ }+ try await asr.downloadModel(.fluidParakeetMini, updateWeights: true, progressHandler: nil)+ XCTAssertFalse(asr.isAsrReady, "The next use must load the replacement checkpoint")+ XCTAssertEqual(settings.selectedSpeechModel, .fluidParakeetMini)+ XCTAssertEqual(provider.clearCalls, 0)+ let deadline = ContinuousClock.now + .seconds(2)+ while asr.activeExclusiveActivity != nil, ContinuousClock.now < deadline {+ try await Task.sleep(for: .milliseconds(1))+ }+ XCTAssertNil(asr.activeExclusiveActivity)+ XCTAssertFalse(asr.hasActiveModelDownload)+ }++ func testLateCancellationAfterCommittedWeightUpdateDoesNotDeleteItsFiles() async throws {+ let settings = SettingsStore.shared+ let selected = settings.selectedSpeechModel+ defer { settings.selectedSpeechModel = selected }+ settings.selectedSpeechModel = .parakeetTDTv2+ let asr = ASRService()+ let provider = DeletionFixtureProvider()+ asr.modelProvidersForTesting[.fluidParakeetMini] = provider+ // The provider returns only after its atomic publication point.+ provider.prepareBody = { withUnsafeCurrentTask { $0?.cancel() } }+ try await asr.downloadModel(.fluidParakeetMini, updateWeights: true, progressHandler: nil)+ XCTAssertEqual(provider.prepareCalls, 1)+ XCTAssertEqual(provider.clearCalls, 0)+ XCTAssertEqual(settings.selectedSpeechModel, .parakeetTDTv2)+ XCTAssertNil(asr.activeExclusiveActivity)+ XCTAssertFalse(asr.hasActiveModelDownload)+ }}diff --git a/Tests/FluidDictationIntegrationTests/ZeppelinDataLayerTests.swift b/Tests/FluidDictationIntegrationTests/ZeppelinDataLayerTests.swiftindex e45948e9..6f4dedd1 100644--- a/Tests/FluidDictationIntegrationTests/ZeppelinDataLayerTests.swift+++ b/Tests/FluidDictationIntegrationTests/ZeppelinDataLayerTests.swift@@ -90,6 +90,69 @@ final class ZeppelinDataLayerTests: XCTestCase {await database.closeAll()}+ func testCloseAllAllowsReopeningWithPersistedRows() async throws {+ let database = FluidZeppelinRoot(root: self.root)+ let first = try await database.namespace("first", spec: Self.spec)+ try await self.seed(first, ids: 1...3)+ await database.closeAll()++ let reopened = try await database.namespace("first", spec: Self.spec)+ XCTAssertFalse(first === reopened, "Closing releases the cached handle")+ let count = try await reopened.count().count+ XCTAssertEqual(count, 3, "A reusable close must preserve indexed rows")+ await database.closeAll()+ }++ func testShutdownRejectsCachedAndNewNamespacesWithoutLosingPersistedRows() async throws {+ let database = FluidZeppelinRoot(root: self.root)+ let opened = try await database.namespace("first", spec: Self.spec)+ try await self.seed(opened, ids: 1...3)+ await database.shutdown()++ for name in ["first", "new-after-shutdown"] {+ do {+ _ = try await database.namespace(name, spec: Self.spec)+ XCTFail("A terminated root must reject \(name)")+ } catch {+ XCTAssertTrue(error is CancellationError, "Shutdown must reject opens explicitly")+ }+ }+ XCTAssertEqual(try self.directories(), ["first"], "A rejected open must not create a directory")++ // A fresh instance, as on the next launch, can open the checkpointed data.+ let relaunched = FluidZeppelinRoot(root: self.root)+ let count = try await relaunched.namespace("first", spec: Self.spec).count().count+ XCTAssertEqual(count, 3, "Shutdown must close handles without deleting rows")+ await relaunched.closeAll()+ }++ func testShutdownAfterReusableCloseStillRejectsReopening() async throws {+ let database = FluidZeppelinRoot(root: self.root)+ _ = try await database.namespace("first", spec: Self.spec)+ await database.closeAll()+ await database.shutdown()+ await database.closeAll()++ do {+ _ = try await database.namespace("first", spec: Self.spec)+ XCTFail("A reusable close after shutdown must not restart the root")+ } catch {+ XCTAssertTrue(error is CancellationError)+ }+ }++ func testShutdownBeforeOpeningCreatesNoIndexFiles() async throws {+ let database = FluidZeppelinRoot(root: self.root)+ await database.shutdown()+ do {+ _ = try await database.namespace("first", spec: Self.spec)+ XCTFail("A never-opened terminated root must reject its first namespace")+ } catch {+ XCTAssertTrue(error is CancellationError)+ }+ XCTAssertFalse(FileManager.default.fileExists(atPath: self.root.path))+ }+// MARK: - Unreadable namespaces are resetfunc testACorruptNamespaceIsResetAndReopenedEmpty() async throws {diff --git a/Tests/HistoryPersistenceBoundaryTests.swift b/Tests/HistoryPersistenceBoundaryTests.swiftindex 09fe0b5b..416f27c3 100644--- a/Tests/HistoryPersistenceBoundaryTests.swift+++ b/Tests/HistoryPersistenceBoundaryTests.swift@@ -238,12 +238,30 @@ final class DebugLogger {return entry}precondition(normalizedRestore == backup, "Backup restore must retain stars and metadata while refreshing search revisions")+ store.selectEntryFromSearch(id: older.id)+ guard let firstRequest = store.searchSelectionRequest else {+ preconditionFailure("Selecting a search result must create a request")+ }+ store.selectEntryFromSearch(id: older.id)+ guard let repeatedRequest = store.searchSelectionRequest else {+ preconditionFailure("Selecting the same result again must create a request")+ }+ precondition(firstRequest != repeatedRequest, "Repeated clicks on the same result must create a fresh bounded request")+ store.consumeSearchSelectionRequest(firstRequest)+ precondition(store.searchSelectionRequest == repeatedRequest, "A stale consumer must not clear the latest search request")+ store.consumeSearchSelectionRequest(repeatedRequest)+ precondition(store.searchSelectionRequest == nil, "The active consumer clears its request")+ store.selectedEntryID = older.id+ store.toggleStar(id: older.id)+ precondition(store.searchSelectionRequest == nil, "Unstar is a local edit, not a sidebar reveal")store.deleteEntry(id: older.id)+ precondition(store.selectedEntryID == newer.id, "Deleting the selected row retains the existing store fallback")+ precondition(store.searchSelectionRequest == nil, "Delete fallback must not reset History filters")store.toggleStar(id: older.id)await store.finishPendingWrites()let afterDelete = try await writer.load()precondition(afterDelete == restored.filter { $0.id == newer.id }, "A stale star action must not resurrect a deleted entry")- print("PASS: star filtering/search, chronology, audio preservation, unstar/restart, backup restore and deletion")+ print("PASS: star filtering/search, chronology, audio preservation, unstar/restart, backup restore, deletion and bounded explicit search requests")}@MainActor static func testTodaySummary(root: URL, defaults: UserDefaults, audio: DictationAudioMetadata) async throws {diff --git a/Tests/HistoryPresentationTests.swift b/Tests/HistoryPresentationTests.swiftindex 12bc3a6b..116c007f 100644--- a/Tests/HistoryPresentationTests.swift+++ b/Tests/HistoryPresentationTests.swift@@ -59,6 +59,35 @@ struct HistoryPresentationTests {aiTokensPerSecond: 746,audio: audio)+ precondition(HistorySelectionRevealPolicy.needsFilterReset(+ requestedID: enhanced.id, selectedID: enhanced.id, allEntries: [enhanced], visibleEntries: []+ ), "An empty Starred or text-filter result must still reveal an existing external selection")+ precondition(!HistorySelectionRevealPolicy.needsFilterReset(+ requestedID: enhanced.id, selectedID: enhanced.id, allEntries: [enhanced], visibleEntries: [enhanced]+ ), "Already visible selections must preserve active filters")+ precondition(!HistorySelectionRevealPolicy.needsFilterReset(+ requestedID: enhanced.id, selectedID: nil, allEntries: [enhanced], visibleEntries: []+ ), "An empty selection must preserve filters")+ let missingID = UUID()+ precondition(!HistorySelectionRevealPolicy.needsFilterReset(+ requestedID: missingID, selectedID: missingID, allEntries: [enhanced], visibleEntries: []+ ), "Missing or deleted selections must preserve filters")+ precondition(!HistorySelectionRevealPolicy.needsFilterReset(+ requestedID: nil, selectedID: enhanced.id, allEntries: [enhanced], visibleEntries: []+ ), "Local deletion fallback, unstar and restore selection must not clear Starred without a search request")+ precondition(!HistorySelectionRevealPolicy.needsFilterReset(+ requestedID: missingID, selectedID: enhanced.id, allEntries: [enhanced], visibleEntries: []+ ), "An older search request cannot override a newer local selection")+ let viewSource = try String(contentsOfFile: "Sources/Fluid/UI/TranscriptionHistoryView.swift", encoding: .utf8)+ let parent = viewSource.components(separatedBy: "private var entryListView:").first ?? ""+ precondition(parent.contains(".onChange(of: self.historyStore.searchSelectionRequest)"), "External selection must be observed outside the conditionally absent list")+ precondition(!parent.contains(".onChange(of: self.historyStore.selectedEntryID)"), "Local selection must not become an external reveal event")+ precondition(parent.contains("self.revealExternalSelection()"), "Parent must use the tested policy")+ precondition(parent.contains("self.audioAvailabilityRevision = UUID()\n self.revealExternalSelection()"), "Initial appearance must reveal the already-selected row")+ precondition(!parent.contains("filteredEntries.map(\\.id), initial: true"), "Initial filter fallback must not erase an external selection before appearance")+ let contentSource = try String(contentsOfFile: "Sources/Fluid/ContentView.swift", encoding: .utf8)+ precondition(contentSource.contains("TranscriptionHistoryStore.shared.selectEntryFromSearch(id: id)"), "Sidebar navigation must produce the explicit request before opening History")+ print("PASS: hidden/empty external reveal, visible/nil/deleted/local/stale non-effects and explicit parent/appearance wiring")let before = enhancedprecondition(enhanced.clipboardText == "final words")precondition(enhanced == before, "Reading copy text must not mutate an entry")diff --git a/Tests/run_dictionary_training_save_tests.py b/Tests/run_dictionary_training_save_tests.pyindex fb40929f..c5c38d3e 100644--- a/Tests/run_dictionary_training_save_tests.py+++ b/Tests/run_dictionary_training_save_tests.py@@ -19,6 +19,9 @@ os.environ["DEVELOPER_DIR"] = developer_dirsource = (repo / 'Sources/Fluid/UI/CustomDictionaryView.swift').read_text()method = source[source.index(' private func addTrainedReplacement() async {'):source.index(' private func removeTrainingVariant(')].replace('private func addTrainedReplacement', 'func addTrainedReplacement')+progress = source[source.index('struct DictionaryTrainingProgress {'):source.index('enum CustomDictionaryTrainingMerge {')]+readiness = source[source.index(' private var trainingProgress:'):source.index(' private var trainingAlreadyCorrectWithoutReplacement:')]+can_save = source[source.index(' private var canAddTrainedReplacement:'):source.index(' private var shouldPulseTrainedReplacementButton:')]merge = source[source.index('enum CustomDictionaryTrainingMerge {'):source.index('private struct ReplacementConfirmation:')]settings = (repo / 'Sources/Fluid/Persistence/SettingsStore.swift').read_text()entry_start = settings.rfind('\n', 0, settings.index('struct CustomDictionaryEntry:')) + 1@@ -36,8 +39,16 @@ enum DictionaryMatcherExperiment {static var generation = UUID()}struct VoiceTrainingAliasFilter {- struct Result { let accepted: [String]; let rejected: [String] = []; let lookupAvailable = true }- static func filter(_ values: [String]) async -> Result { Result(accepted: values) }+ struct Result {+ let accepted: [String]+ let rejected: [String] = []+ let lookupAvailable: Bool+ init(accepted: [String], lookupAvailable: Bool = true) {+ self.accepted = accepted; self.lookupAvailable = lookupAvailable+ }+ }+ static var response: Result?+ static func filter(_ values: [String]) async -> Result { response ?? Result(accepted: values) }}final class DebugLogger {static let shared = DebugLogger()@@ -56,10 +67,12 @@ actor PronunciationDictionaryStore {var lateGate: Gate?var forceFailure = falsevar writes: [UUID] = []+ var calls = 0func configure(gate: Gate?, lateGate: Gate? = nil, failure: Bool = false) {- self.gate = gate; self.lateGate = lateGate; forceFailure = failure; writes = []+ self.gate = gate; self.lateGate = lateGate; forceFailure = failure; writes = []; calls = 0}func upsert(dictionaryEntryID: UUID, label: String, modelKey: String, enrollments: [PronunciationEnrollmentCapture], automaticMatchingEnabled: Bool, canPersist: @Sendable () -> Bool) async throws {+ calls += 1guard canPersist() else { throw CancellationError() }if let gate { await gate.pause() }guard canPersist(), !forceFailure else { throw CancellationError() }@@ -67,13 +80,17 @@ actor PronunciationDictionaryStore {if let lateGate { await lateGate.pause() }}}+PROGRESSMERGE@MainActor final class SaveHarness {- var canAddTrainedReplacement = true+ READINESS+ CAN_SAVE+ var trainingSampleCount = 3+ var isTrainingRecording = falsevar isTrainingProcessing = falsevar trainingSaveID: UUID?var normalizedTrainingReplacement = "FluidVoice"- var trainingPronunciationEnrollments = [PronunciationEnrollmentCapture()]+ var trainingPronunciationEnrollments = Array(repeating: PronunciationEnrollmentCapture(), count: 3)var activePronunciationMatching = truevar trainingVariants = ["fluid boys"]var pronunciationEnabled = true@@ -102,9 +119,16 @@ func check(_ condition: @autoclosure () -> Bool, _ message: String) {SettingsStore.shared.customDictionaryEntries = entriesDictionaryMatcherExperiment.sharedFeaturesEnabled = trueDictionaryMatcherExperiment.generation = UUID()+ VoiceTrainingAliasFilter.response = nilreturn SaveHarness()}- func waitForGate(_ gate: Gate) async { while !(await gate.entered) { await Task.yield() } }+ func waitForGate(_ gate: Gate) async throws {+ let deadline = ContinuousClock.now + .seconds(3)+ while !(await gate.entered) {+ check(ContinuousClock.now < deadline, "Save did not reach its expected persistence boundary within 3 seconds")+ try await Task.sleep(for: .milliseconds(1))+ }+ }// Production save and merge retain existing profile UUID and save new entries under the written UUID.for existing in [true, false] {let original = existing ? baseline() : []@@ -125,7 +149,7 @@ func check(_ condition: @autoclosure () -> Bool, _ message: String) {let gate = Gate()await PronunciationDictionaryStore.shared.configure(gate: gate)let save = Task { await view.addTrainedReplacement() }- await waitForGate(gate)+ try await waitForGate(gate)var latest = originalswitch mutation {case 0: latest.append(Entry(triggers: ["new"], replacement: "New"))@@ -154,7 +178,7 @@ func check(_ condition: @autoclosure () -> Bool, _ message: String) {let lateGate = Gate()await PronunciationDictionaryStore.shared.configure(gate: nil, lateGate: lateGate)let save = Task { await view.addTrainedReplacement() }- await waitForGate(lateGate)+ try await waitForGate(lateGate)let latest = [original[1]]SettingsStore.shared.customDictionaryEntries = latestawait lateGate.release(); await save.value@@ -168,7 +192,7 @@ func check(_ condition: @autoclosure () -> Bool, _ message: String) {let gate = Gate()await PronunciationDictionaryStore.shared.configure(gate: gate, failure: true)let save = Task { await view.addTrainedReplacement() }- await waitForGate(gate)+ try await waitForGate(gate)let newSaveID = UUID()view.trainingSaveID = newSaveIDview.trainingStatusMessage = "new save"@@ -199,10 +223,105 @@ func check(_ condition: @autoclosure () -> Bool, _ message: String) {check(await PronunciationDictionaryStore.shared.writes.isEmpty, "Text-only training must not write profiles")passes += 1}- print("PASS \(passes) dictionary save scenarios using the production save method and merge code")+ // Three spelling examples may save even when voice enrollment is incomplete.+ // The actual readiness calculation must keep zero, one and two voice examples+ // out of profile persistence, even with pronunciation learning enabled.+ for count in 0..<3 {+ let original = baseline()+ let view = reset(original)+ view.trainingPronunciationEnrollments = Array(repeating: PronunciationEnrollmentCapture(), count: count)+ await PronunciationDictionaryStore.shared.configure(gate: nil, failure: true)+ await view.addTrainedReplacement()+ let calls = await PronunciationDictionaryStore.shared.calls+ let profiles = await PronunciationDictionaryStore.shared.writes+ check(view.writes == 1 && view.wizardStep == .saved, "Incomplete voice enrollment must not block spelling-only save")+ check(calls == 0 && profiles.isEmpty, "Incomplete voice examples must never enter profile persistence")+ check(SettingsStore.shared.customDictionaryEntries.first?.id == original.first?.id, "Spelling fallback retains the existing entry identity")+ check(SettingsStore.shared.customDictionaryEntries.last == original.last, "Spelling fallback preserves unrelated rules")+ check(!view.trainingHasError && !view.isTrainingProcessing && view.trainingSaveID == nil, "Spelling fallback finishes cleanly")+ passes += 1+ }+ // Filtering cannot create a text rule when no safe aliases and no ready voice exist.+ for available in [true, false] {+ let original = baseline()+ let view = reset(original)+ view.trainingPronunciationEnrollments = []+ VoiceTrainingAliasFilter.response = .init(accepted: [], lookupAvailable: available)+ await PronunciationDictionaryStore.shared.configure(gate: nil)+ await view.addTrainedReplacement()+ let calls = await PronunciationDictionaryStore.shared.calls+ check(view.writes == 0 && calls == 0, "Rejected aliases must not write text rules or profiles")+ check(SettingsStore.shared.customDictionaryEntries == original, "Rejected aliases preserve the dictionary")+ check(view.trainingHasError && view.wizardStep == .recording, "Rejected or unavailable aliases leave a visible retry")+ check(view.trainingStatusMessage.contains(available ? "everyday words" : "Couldn't check"), "Alias failure explains its actual cause")+ check(!view.trainingVariants.isEmpty && !view.isTrainingProcessing && view.trainingSaveID == nil, "Alias failure retains recordings and releases busy state")+ passes += 1+ }+ // Insufficient spellings use the production save gate, even with enough voice examples.+ do {+ let original = baseline()+ let view = reset(original)+ view.trainingSampleCount = 2+ await PronunciationDictionaryStore.shared.configure(gate: nil)+ await view.addTrainedReplacement()+ let calls = await PronunciationDictionaryStore.shared.calls+ check(calls == 0 && view.writes == 0 && SettingsStore.shared.customDictionaryEntries == original, "Incomplete spellings must not save")+ check(!view.isTrainingProcessing && view.trainingSaveID == nil && view.wizardStep == .recording, "Rejected save must not advance the wizard or leave it busy")+ passes += 1+ }+ // A new feature generation while the store is suspended rejects old enrollment.+ do {+ let original = baseline()+ let view = reset(original)+ let gate = Gate()+ await PronunciationDictionaryStore.shared.configure(gate: gate)+ let save = Task { await view.addTrainedReplacement() }+ try await waitForGate(gate)+ DictionaryMatcherExperiment.generation = UUID()+ await gate.release(); await save.value+ let profiles = await PronunciationDictionaryStore.shared.writes+ check(profiles.isEmpty && view.writes == 0 && SettingsStore.shared.customDictionaryEntries == original, "Stale pronunciation generation must not persist")+ check(view.trainingHasError && !view.trainingPronunciationEnrollments.isEmpty, "Generation refusal is retryable and retains captured examples")+ check(!view.isTrainingProcessing && view.trainingSaveID == nil, "Generation refusal must release busy state")+ passes += 1+ }+ // A completion from an older save must not clear or advance a newer save.+ do {+ let original = baseline()+ let view = reset(original)+ let lateGate = Gate()+ await PronunciationDictionaryStore.shared.configure(gate: nil, lateGate: lateGate)+ let save = Task { await view.addTrainedReplacement() }+ try await waitForGate(lateGate)+ let newerID = UUID()+ view.trainingSaveID = newerID+ view.trainingStatusMessage = "New save is running"+ await lateGate.release(); await save.value+ check(view.writes == 0 && SettingsStore.shared.customDictionaryEntries == original, "Stale success must not publish text rules")+ check(view.trainingSaveID == newerID && view.isTrainingProcessing, "Stale success must not release the newer save")+ check(view.trainingStatusMessage == "New save is running" && view.wizardStep == .recording && !view.trainingHasError, "Stale success must preserve newer UI state")+ passes += 1+ }+ // Cancellation after profile completion suppresses dictionary publication and wizard success.+ // This deliberately does not claim cancellation rolls back an already completed profile write.+ do {+ let original = baseline()+ let view = reset(original)+ let lateGate = Gate()+ await PronunciationDictionaryStore.shared.configure(gate: nil, lateGate: lateGate)+ let save = Task { await view.addTrainedReplacement() }+ try await waitForGate(lateGate)+ save.cancel()+ await lateGate.release(); await save.value+ check(view.writes == 0 && SettingsStore.shared.customDictionaryEntries == original, "Cancelled save must not publish dictionary changes")+ check(!view.isTrainingProcessing && view.trainingSaveID == nil && view.wizardStep == .recording && !view.trainingHasError, "Cancelled completion must leave no success, error or busy state")+ check(!view.trainingPronunciationEnrollments.isEmpty, "Cancelled save retains captures for retry")+ passes += 1+ }+ print("PASS \(passes) dictionary save scenarios using the production save method, readiness and merge code")}}-'''.replace('ENTRY', entry).replace('MERGE', merge).replace('METHOD', method)+'''.replace('ENTRY', entry).replace('PROGRESS', progress).replace('MERGE', merge).replace('READINESS', readiness).replace('CAN_SAVE', can_save).replace('METHOD', method)swift = swift.replace('check(await PronunciationDictionaryStore.shared.writes.isEmpty,', 'let textOnlyWrites = await PronunciationDictionaryStore.shared.writes\n check(textOnlyWrites.isEmpty,')isolation_swift = r'''import Foundation@@ -229,12 +348,12 @@ actor SnapshotReader {with tempfile.TemporaryDirectory(prefix="fluidvoice-dictionary-regression-") as directory:root = Path(directory)(root / 'dictionary-proof.swift').write_text(swift)- subprocess.run(['xcrun', 'swiftc', '-parse-as-library', str(root/'dictionary-proof.swift'), '-o', str(root/'dictionary-proof')], check=True)- subprocess.run([str(root/'dictionary-proof')], check=True)+ subprocess.run(['xcrun', 'swiftc', '-parse-as-library', str(root/'dictionary-proof.swift'), '-o', str(root/'dictionary-proof')], check=True, timeout=60)+ subprocess.run([str(root/'dictionary-proof')], check=True, timeout=60)(root / 'dictionary-isolation.swift').write_text(isolation_swift)subprocess.run(['xcrun', 'swiftc', '-parse-as-library', '-swift-version', '6','-default-isolation', 'MainActor', '-strict-concurrency=complete', '-warnings-as-errors',str(root/'dictionary-isolation.swift'), '-o', str(root/'dictionary-isolation'),- ], check=True)- subprocess.run([str(root/'dictionary-isolation')], check=True)+ ], check=True, timeout=60)+ subprocess.run([str(root/'dictionary-isolation')], check=True, timeout=60)diff --git a/Tests/run_meeting_backup_refresh_tests.py b/Tests/run_meeting_backup_refresh_tests.pynew file mode 100644index 00000000..e1d0f479--- /dev/null+++ b/Tests/run_meeting_backup_refresh_tests.py@@ -0,0 +1,213 @@+#!/usr/bin/env python3+"""Exercise the production meeting backup handlers without hardware or app defaults."""+import argparse+import os+from pathlib import Path+import subprocess+import tempfile++ROOT = Path(__file__).resolve().parents[1]+SOURCE = ROOT / "Sources/Fluid/UI/MeetingTranscriptionView.swift"+++def declaration(source: str, marker: str) -> str:+ start = source.index(marker)+ brace = source.index("{", start)+ depth = 1+ end = brace + 1+ while depth:+ depth += (source[end] == "{") - (source[end] == "}")+ end += 1+ return source[start:end]+++def main() -> None:+ parser = argparse.ArgumentParser(description=__doc__)+ parser.add_argument("--baseline-ref", help="Optional pre-fix git ref for reproduction checks")+ args = parser.parse_args()+ developer_dir = os.environ.get("DEVELOPER_DIR") or subprocess.check_output(+ ["xcode-select", "-p"], text=True, timeout=10+ ).strip()+ if not ("Xcode" in developer_dir and developer_dir.endswith(".app/Contents/Developer")):+ raise SystemExit("Set DEVELOPER_DIR to a full installed Xcode before running tests.")+ env = {**os.environ, "DEVELOPER_DIR": developer_dir}+ source = SOURCE.read_text()+ baseline = None+ if args.baseline_ref:+ baseline = subprocess.check_output(+ ["git", "show", f"{args.baseline_ref}:Sources/Fluid/UI/MeetingTranscriptionView.swift"],+ cwd=ROOT, text=True, timeout=10,+ )+ assert "settingsBackupDidRestore" not in baseline+ assert "self.appDetailContent\n" in (ROOT / "Sources/Fluid/ContentView.swift").read_text()+ assert ".onReceive(NotificationCenter.default.publisher(for: .settingsBackupDidRestore))" in source+ assert ".onChange(of: self.canRefreshSetupAfterBackupRestore)" in source+ mode_observer = declaration(source, ".onChange(of: self.setupDraft.mode)")+ assert "Task { await self.refreshSources(requestPermissions: false) }" in mode_observer+ for action in ("cancelMeetingSettings", "saveMeetingSettings"):+ body = declaration(source, f"private func {action}()")+ assert body.split("{", 1)[1].strip().startswith(+ "if self.finishRestoredMeetingSettingsIfPending() { return }"+ ), f"{action} must reject stale sheet writes before validation or source refresh"++ draft = declaration(source, "struct MeetingTranscriptionSetupDraft:")+ if baseline is not None:+ assert draft == declaration(baseline, "struct MeetingTranscriptionSetupDraft:")+ members = "\n".join(declaration(source, marker) for marker in (+ "private var canRefreshSetupAfterBackupRestore:",+ "private func applyPendingBackupSetupRefresh()",+ "private func finishRestoredMeetingSettingsIfPending()",+ ))+ swift = r'''+import Foundation++enum MeetingCaptureMode { case onlineCall, inRoom }+struct Defaults { var languageCode: String? = "en"; var mode: MeetingCaptureMode = .onlineCall }+final class SettingsStore {+ static let shared = SettingsStore()+ var meetingRecordingDefaults = Defaults()+ var meetingAutoDetectEnabled = true+ var meetingAutoDetectBrowserEnabled = true+ var meetingAudioRetentionPolicy = 7+}+struct Identity { let id: String }+struct Option { let identity: Identity }+final class Coordinator { var isQuiescent = true; var activeLanguage = "en" }+''' + draft + r'''+final class Harness {+ let coordinator = Coordinator()+ var setupDraft = MeetingTranscriptionSetupDraft()+ var setupDraftBeforeEditing = MeetingTranscriptionSetupDraft()+ var pendingBackupSetupRefresh = false+ var cachedSystemDefaultMicrophoneUID: String? = "cached-mic"+ var isStarting = false, isStopping = false, isRetrying = false+ var isRefreshingSources = false, isShowingMeetingSettings = false+ var microphones = [Option(identity: Identity(id: "cached-mic"))]+ var applications = [Option(identity: Identity(id: "cached-app"))]+ var draftMeetingAudioRetentionPolicy = 7+ var selectedIdentities = 0+ var persistedWrites = 0+ var hardwareQueries = 0+ func selectPreferredMicrophone(from identities: [Identity], systemDefaultUID: String?) {+ selectedIdentities += 1+ setupDraft.selectedMicrophoneID = identities.first(where: { $0.id == systemDefaultUID })?.id+ }+ func selectPreferredApplication(from identities: [Identity]) {+ selectedIdentities += 1+ setupDraft.selectedApplicationID = identities.first?.id+ }+ func regenerateDefaultTitleIfNeeded() {+ if !setupDraft.titleWasEdited {+ setupDraft.title = MeetingTranscriptionSetupDraft.defaultTitle(mode: setupDraft.mode, applicationDisplayName: nil)+ }+ }+''' + members + r'''+ func notifyRestore() { pendingBackupSetupRefresh = true; applyPendingBackupSetupRefresh() }+ func reachSafePoint() { if canRefreshSetupAfterBackupRestore { applyPendingBackupSetupRefresh() } }+ func closeSheetSaving() {+ if finishRestoredMeetingSettingsIfPending() { return }+ persistedWrites += 1+ }+ func closeSheetCancelling() {+ if finishRestoredMeetingSettingsIfPending() { return }+ hardwareQueries += 1+ }+ func expect(_ ok: Bool, _ message: String) { check(ok, message) }+}+var assertions = 0+func check(_ ok: Bool, _ message: String) {+ assertions += 1+ if !ok { fatalError(message) }+}+func restored(_ language: String = "fr", _ mode: MeetingCaptureMode = .inRoom) {+ SettingsStore.shared.meetingRecordingDefaults = Defaults(languageCode: language, mode: mode)+}+func fresh() -> Harness {+ restored("en", .onlineCall)+ SettingsStore.shared.meetingAutoDetectEnabled = true+ SettingsStore.shared.meetingAutoDetectBrowserEnabled = true+ SettingsStore.shared.meetingAudioRetentionPolicy = 7+ return Harness()+}+@main enum Tests {+ static func main() {+ // Reproduce pre-fix: real production draft is a value snapshot, not a settings binding.+ let baseline = fresh()+ restored()+ check(baseline.setupDraft.languageCode == "en" && baseline.setupDraft.mode == .onlineCall,+ "baseline hidden page keeps stale language/mode after defaults import")+ print("PASS: setup draft is a snapshot; restore notification must refresh it")+ baseline.notifyRestore()+ check(baseline.setupDraft.languageCode == "fr" && baseline.setupDraft.mode == .inRoom, "idle restore refreshes language/mode")+ check(baseline.setupDraftBeforeEditing == baseline.setupDraft, "cancel snapshot follows restored setup")+ check(baseline.hardwareQueries == 0 && baseline.persistedWrites == 0, "restore handler performs neither synchronous source queries nor persistence")+ check(baseline.setupDraft.selectedMicrophoneID == "cached-mic" && baseline.setupDraft.selectedApplicationID == "cached-app", "cached identities populate restored setup")+ check(baseline.coordinator.activeLanguage == "en", "active capture configuration is never rewritten")++ for blocker in 0..<6 {+ let h = fresh()+ switch blocker {+ case 0: h.coordinator.isQuiescent = false+ case 1: h.isStarting = true+ case 2: h.isStopping = true+ case 3: h.isRetrying = true+ case 4: h.isRefreshingSources = true+ default: h.isShowingMeetingSettings = true+ }+ h.setupDraft.title = "User's meeting"; h.setupDraft.titleWasEdited = true+ restored(); h.notifyRestore()+ check(h.pendingBackupSetupRefresh && h.setupDraft.languageCode == "en", "busy/editing restore defers \(blocker)")+ check(h.selectedIdentities == 0 && h.persistedWrites == 0, "deferral has no effects \(blocker)")+ restored("de", .onlineCall); h.notifyRestore()+ check(h.setupDraft.title == "User's meeting", "repeated restore preserves active edited input \(blocker)")+ h.coordinator.isQuiescent = true; h.isStarting = false; h.isStopping = false+ h.isRetrying = false; h.isRefreshingSources = false; h.isShowingMeetingSettings = false+ h.reachSafePoint()+ check(!h.pendingBackupSetupRefresh && h.setupDraft.languageCode == "de", "success/failure/close uses latest coalesced restore \(blocker)")+ check(h.setupDraft.title == "User's meeting" && h.setupDraft.titleWasEdited, "custom title survives refresh \(blocker)")+ let identityCount = h.selectedIdentities+ h.reachSafePoint()+ check(h.selectedIdentities == identityCount, "safe-point events do not replay completed restore \(blocker)")+ }+ for save in [false, true] {+ let h = fresh(); h.isShowingMeetingSettings = true+ restored(); h.notifyRestore()+ if save { h.closeSheetSaving() } else { h.closeSheetCancelling() }+ check(!h.isShowingMeetingSettings && h.setupDraft.languageCode == "fr", "sheet close consumes deferred restore")+ check(h.persistedWrites == 0 && h.hardwareQueries == 0, "stale Save/Cancel cannot overwrite imported preferences or query sources")+ }+ let busySheet = fresh(); busySheet.isShowingMeetingSettings = true; busySheet.coordinator.isQuiescent = false+ restored(); busySheet.notifyRestore(); busySheet.closeSheetSaving()+ check(busySheet.pendingBackupSetupRefresh && busySheet.setupDraft.languageCode == "en", "closing edited sheet does not change busy capture setup")+ busySheet.coordinator.isQuiescent = true; busySheet.reachSafePoint()+ check(busySheet.setupDraft.languageCode == "fr" && busySheet.persistedWrites == 0, "capture failure/completion later applies pending sheet restore without writes")++ let rapid = fresh()+ restored(); rapid.notifyRestore()+ restored("de", .onlineCall); rapid.notifyRestore()+ check(rapid.setupDraft.languageCode == "de" && rapid.setupDraft.mode == .onlineCall, "rapid change-back restore keeps latest values")+ restored("fr", .inRoom); rapid.notifyRestore(); restored("de", .inRoom); rapid.notifyRestore()+ check(rapid.setupDraft.languageCode == "de" && !rapid.pendingBackupSetupRefresh, "same-mode repeated restores consume latest language without stale pending state")+ let legacy = fresh(); SettingsStore.shared.meetingRecordingDefaults.languageCode = nil+ legacy.notifyRestore()+ check(legacy.setupDraft.languageCode == "en" && legacy.hardwareQueries == 0, "legacy language defaults to English without source discovery")+ let missing = fresh(); missing.microphones = []; missing.applications = []+ restored(); missing.notifyRestore()+ check(missing.setupDraft.selectedMicrophoneID == nil && missing.setupDraft.selectedApplicationID == nil, "missing cached sources stay unselected")+ check(missing.hardwareQueries == 0 && !missing.pendingBackupSetupRefresh, "missing sources do not create a permanent pending restore")+ print("PASS: \(assertions) production-handler assertions")+ }+}+'''+ with tempfile.TemporaryDirectory(prefix="fluidvoice-meeting-backup-") as directory:+ directory = Path(directory)+ swift_file = directory / "Tests.swift"+ swift_file.write_text(swift)+ executable = directory / "tests"+ subprocess.run(["xcrun", "swiftc", "-parse-as-library", str(swift_file), "-o", str(executable)],+ env=env, check=True, timeout=60)+ subprocess.run([str(executable)], env=env, check=True, timeout=15)+++if __name__ == "__main__":+ main()diff --git a/Tests/run_settings_backup_concurrency_tests.py b/Tests/run_settings_backup_concurrency_tests.pynew file mode 100644index 00000000..b263ddeb--- /dev/null+++ b/Tests/run_settings_backup_concurrency_tests.py@@ -0,0 +1,562 @@+#!/usr/bin/env python3+"""Test source-extracted backup methods with bounded real-actor dependency probes.++No production defaults, disk stores, UI, hardware, or network are used.+--ref REF --expect-overlap-gap reproduces a historical overlapping snapshot gap.+Normal execution needs only the current source, including its single-flight gate.+"""++import argparse+import os+from pathlib import Path+import subprocess+import tempfile+++def declaration(source: str, marker: str) -> str:+ start = source.index(marker)+ brace = source.index("{", start)+ depth, end = 1, brace + 1+ while depth:+ depth += (source[end] == "{") - (source[end] == "}")+ end += 1+ return source[start:end]+++def main() -> None:+ parser = argparse.ArgumentParser(description=__doc__)+ parser.add_argument("--ref")+ probes = parser.add_mutually_exclusive_group()+ probes.add_argument("--expect-overlap-gap", action="store_true")+ probes.add_argument("--expect-active-work-gap", action="store_true")+ args = parser.parse_args()+ repo = Path(__file__).resolve().parent.parent+ selected = subprocess.check_output(["xcode-select", "-p"], text=True, timeout=10).strip()+ developer_dir = os.environ.get("DEVELOPER_DIR", selected)+ if not (Path(developer_dir) / "Platforms/MacOSX.platform").is_dir():+ raise SystemExit("Set DEVELOPER_DIR to a full installed Xcode before running this test.")+ environment = dict(os.environ, DEVELOPER_DIR=developer_dir)+ source_path = "Sources/Fluid/Persistence/BackupService.swift"+ source = (+ subprocess.check_output(["git", "show", f"{args.ref}:{source_path}"], cwd=repo, text=True, timeout=10)+ if args.ref else (repo / source_path).read_text()+ )+ members = "\n".join(declaration(source, marker) for marker in (+ " func makeBackupDocument() async throws -> AppBackupDocument",+ " func restore(_ document: AppBackupDocument) async throws",+ " private func validate(_ document: AppBackupDocument)",+ ))+ if "private var operationInProgress" in source:+ # Extract the actual gate storage and admission method, never a mirrored gate.+ gate_line = next(line for line in source.splitlines() if "private var operationInProgress" in line)+ members = gate_line + "\n" + declaration(source, " private func beginOperation()") + "\n" + members+ errors = declaration(source, "enum BackupServiceError:")+ schema = declaration(source, "struct BackupFileVersion:")+ asr_source = (repo / "Sources/Fluid/Services/ASRService.swift").read_text()+ asr_admission = declaration(asr_source, " func beginSettingsBackupRestore()")+ asr_activity = declaration(asr_source, "enum ASRExclusiveActivity:")+ asr_error = declaration(asr_source, "enum ASRActivityError:")+ asr_release = declaration(asr_source, " func releaseExclusiveActivity(")+ asr_restore = declaration(asr_source, " func handleSettingsBackupDidRestore()")+ swift = r'''+import Foundation+SCHEMA+ERRORS+struct Payload: Codable {+ var owner: String+ var privateAIIdleUnload: Int?+ var meetingLanguage: String? = nil+ var promptConfigurations: [String: String]? = nil+}+struct AppBackupDocument {+ var schemaVersion: BackupFileVersion = .current+ var appVersion = "fixture"+ var exportedAt = Date()+ var settings: Payload+ var promptProfiles: [String] = []+ var appPromptBindings: [String] = []+ var transcriptionHistory: [String] = []+ var pronunciationProfiles: [String]?+}+@MainActor final class SettingsStore {+ static let shared = SettingsStore()+ var owner = "original"+ var privateAIIdleUnload = 30+ var meetingLanguage = "en"+ var configurations = ["__default__": "original"]+ var dictationPromptProfiles: [String] = []+ var appPromptBindings: [String] = []+ func makeBackupPayload() -> Payload {+ .init(owner: owner, privateAIIdleUnload: privateAIIdleUnload,+ meetingLanguage: meetingLanguage, promptConfigurations: configurations)+ }+ func restore(from payload: Payload, promptProfiles: [String], appPromptBindings: [String]) {+ owner = payload.owner+ if let idle = payload.privateAIIdleUnload { privateAIIdleUnload = idle }+ if let language = payload.meetingLanguage { meetingLanguage = language }+ if let configurations = payload.promptConfigurations { self.configurations = configurations }+ dictationPromptProfiles = promptProfiles+ self.appPromptBindings = appPromptBindings+ }+}+actor Gate {+ var entered = false+ var continuation: CheckedContinuation<Void, Never>?+ func pause() async { entered = true; await withCheckedContinuation { continuation = $0 } }+ func release() { continuation?.resume(); continuation = nil }+}+enum ProbeFailure: Error { case storage }+actor PronunciationDictionaryStore {+ static let shared = PronunciationDictionaryStore()+ var profiles = ["original"]+ var reject = false+ var exportGate: Gate?+ var restoreGate: Gate?+ var snapshots = 0, replacements = 0+ func setup(reject: Bool = false, exportGate: Gate? = nil, restoreGate: Gate? = nil) {+ profiles = ["original"]; self.reject = reject+ self.exportGate = exportGate; self.restoreGate = restoreGate+ snapshots = 0; replacements = 0+ }+ func allProfiles() async -> [String] {+ snapshots += 1+ let snapshot = profiles+ if let gate = exportGate { exportGate = nil; await gate.pause() }+ return snapshot+ }+ func replaceAllProfiles(_ profiles: [String]) async throws {+ replacements += 1+ if let gate = restoreGate { restoreGate = nil; await gate.pause() }+ if reject { throw ProbeFailure.storage }+ self.profiles = profiles+ }+ func ordinaryEdit(_ profiles: [String]) { self.profiles = profiles }+ func state() -> ([String], Int, Int) { (profiles, snapshots, replacements) }+}+@MainActor final class TranscriptionHistoryStore {+ static let shared = TranscriptionHistoryStore()+ var history = ["original"]+ var loaded = true+ var loadGate: Gate?+ var loads = 0, writes = 0+ func waitUntilLoaded() async throws {+ loads += 1+ if let gate = loadGate { loadGate = nil; await gate.pause() }+ if !loaded { throw ProbeFailure.storage }+ }+ func makeBackupPayload() -> [String] { history }+ func restore(from payload: [String]) { writes += 1; history = payload }+}+actor IdleDouble {+ var gate: Gate?+ var calls = 0+ var observations: [Int] = []+ func setup(gate: Gate? = nil) { self.gate = gate; calls = 0; observations = [] }+ func settingsChanged() async {+ calls += 1+ if let gate { self.gate = nil; await gate.pause() }+ observations.append(await SettingsStore.shared.privateAIIdleUnload)+ }+ func state() -> (Int, [Int]) { (calls, observations) }+}+enum PrivateAIIntegrationService { static let idleUnloader = IdleDouble() }+@MainActor final class NotificationCenter {+ static let `default` = NotificationCenter()+ var snapshots: [(String, [String])] = []+ var onPost: (() -> Void)?+ enum Name { case settingsBackupDidRestore }+ func post(name: Name, object: Any?) {+ snapshots.append((SettingsStore.shared.owner, TranscriptionHistoryStore.shared.history))+ onPost?()+ }+}+ASR_ACTIVITY+ASR_ERROR+struct ASRActivityLease: Equatable { let id: UUID; let activity: ASRExclusiveActivity }+@MainActor final class HandoffProbe { var isRecovering = false }+@MainActor final class ResidencyProbe { var isExclusive = false }+@MainActor final class ASRService {+ var isTerminating = false+ var activeActivityLease: ASRActivityLease?+ var activeExclusiveActivity: ASRExclusiveActivity?+ var isRunning = false, isStarting = false, isStoppingFinalTranscription = false+ let recordingBufferHandoffGate = HandoffProbe()+ var isMicrophonePreviewRequested = false, isMicrophonePreviewActive = false+ var hasActiveModelDownload = false, hasActiveModelPreparation = false+ var deletingModelID: String?, providerResetDrain: UUID?+ var isCancellingModelPreparation = false, isCancellingModelDownload = false+ let meetingModelResidency = ResidencyProbe()+ var isAsrReady = true, isDownloadingModel = false, isLoadingModel = false+ var admissions = 0+ var releases: Int { DictionaryAudioLearningService.shared.activityEnds }+ var providerResetPending = false+ var deferredMeetingActivityLeaseRelease: ASRActivityLease?+ var completedResets = 0, recoveryRequests = 0+ ASR_ADMISSION+ func acquireExclusiveActivity(_ activity: ASRExclusiveActivity) throws -> ASRActivityLease {+ guard activeActivityLease == nil else { throw ASRActivityError.activityInProgress(activeExclusiveActivity!) }+ let lease = ASRActivityLease(id: UUID(), activity: activity)+ activeActivityLease = lease; activeExclusiveActivity = activity; admissions += 1; return lease+ }+ ASR_RELEASE+ ASR_RESTORE+ func isMeetingASRClaimBlocking(lease: ASRActivityLease) -> Bool { false }+ func resetTranscriptionProvider() {+ if activeActivityLease != nil { providerResetPending = true; return }+ isAsrReady = false; completedResets += 1+ }+ func scheduleAudioRouteRecovery(reason: String, requiresIdlePrewarm: Bool, reconcilesInputSelection: Bool) {+ recoveryRequests += 1+ }+}+@MainActor final class DictionaryAudioLearningService {+ static let shared = DictionaryAudioLearningService()+ var activityEnds = 0+ func activityDidEnd() { activityEnds += 1 }+}+@MainActor final class SpeechModelInstallationSnapshot {+ static let shared = SpeechModelInstallationSnapshot()+ func refresh() {}+}+@MainActor final class AppServices {+ static let shared = AppServices()+ var asr = ASRService()+}+@MainActor final class BackupService {+MEMBERS+}+@MainActor var assertions = 0+@MainActor func expect(_ condition: Bool, _ message: String) {+ assertions += 1+ if !condition { fatalError("FAIL: " + message) }+}+@MainActor func busy(_ work: () async throws -> Void) async {+ do { try await work(); fatalError("Expected busy rejection") }+ catch BackupServiceError.operationInProgress {+ expect(BackupServiceError.operationInProgress.localizedDescription.contains("already running"), "busy error tells user to retry")+ } catch { fatalError("Wrong busy error: \(error)") }+}+@MainActor func reset(idleGate: Gate? = nil, exportGate: Gate? = nil, restoreGate: Gate? = nil) async {+ AppServices.shared.asr = ASRService()+ DictionaryAudioLearningService.shared.activityEnds = 0+ SettingsStore.shared.owner = "original"+ SettingsStore.shared.privateAIIdleUnload = 30+ SettingsStore.shared.meetingLanguage = "en"+ SettingsStore.shared.configurations = ["__default__": "original"]+ SettingsStore.shared.dictationPromptProfiles = []+ SettingsStore.shared.appPromptBindings = []+ TranscriptionHistoryStore.shared.history = ["original"]+ TranscriptionHistoryStore.shared.loaded = true+ TranscriptionHistoryStore.shared.loads = 0; TranscriptionHistoryStore.shared.writes = 0+ TranscriptionHistoryStore.shared.loadGate = nil+ NotificationCenter.default.snapshots = []; NotificationCenter.default.onPost = nil+ await PronunciationDictionaryStore.shared.setup(exportGate: exportGate, restoreGate: restoreGate)+ await PrivateAIIntegrationService.idleUnloader.setup(gate: idleGate)+}+func awaitGate(_ gate: Gate) async {+ let deadline = ContinuousClock.now + .seconds(3)+ while !(await gate.entered) {+ if ContinuousClock.now > deadline { fatalError("Timed out waiting for actor gate") }+ try? await Task.sleep(for: .milliseconds(1))+ }+}+@MainActor func document(_ owner: String, idle: Int? = 60) -> AppBackupDocument {+ .init(settings: .init(owner: owner, privateAIIdleUnload: idle),+ promptProfiles: [owner], appPromptBindings: [owner],+ transcriptionHistory: [owner], pronunciationProfiles: [owner])+}+@main struct Run {+ @MainActor static func main() async throws {+ let service = BackupService()+ // Export suspended after obtaining old pronunciation; concurrent import used+ // to make the eventual settings/History snapshot belong to a different backup.+ let exportGate = Gate()+ await reset(exportGate: exportGate)+ let firstExport = Task { try await service.makeBackupDocument() }+ await awaitGate(exportGate)+ OVERLAP_ACTION+ await exportGate.release()+ let snapshot = try await firstExport.value+ OVERLAP_ASSERTION+ CURRENT_TESTS+ }+}+'''.replace("SCHEMA", schema).replace("ERRORS", errors).replace("MEMBERS", members).replace("ASR_ACTIVITY", asr_activity).replace("ASR_ERROR", asr_error).replace("ASR_ADMISSION", asr_admission).replace("ASR_RELEASE", asr_release).replace("ASR_RESTORE", asr_restore)++ if args.expect_active_work_gap:+ swift = swift[:swift.index("@main struct Run")] + r'''+@main struct Run {+ @MainActor static func main() async throws {+ let service = BackupService()+ await reset()+ let asr = AppServices.shared.asr+ asr.isRunning = true+ let dictation = try asr.acquireExclusiveActivity(.dictation)+ try await service.restore(document("changed-during-dictation", idle: nil))+ let state = await PronunciationDictionaryStore.shared.state()+ expect(SettingsStore.shared.owner == "changed-during-dictation" && state.0 == ["changed-during-dictation"], "historical restore changes settings/profiles during dictation")+ expect(TranscriptionHistoryStore.shared.writes == 1 && NotificationCenter.default.snapshots.count == 1, "historical restore publishes history and restore callbacks while recording")+ expect(asr.activeActivityLease == dictation && asr.isRunning, "the ongoing dictation did not release its lease before the restore")+ print("REPRODUCED: backup changes settings/profiles/history and posts restore callbacks while dictation still owns its recording lease")+ }+}+'''+ elif args.expect_overlap_gap:+ # Historical enum lacks the busy case, so remove the current-only helper.+ start = swift.index("@MainActor func busy(")+ end = swift.index("@MainActor func reset(", start)+ swift = swift[:start] + swift[end:]+ swift = swift.replace("OVERLAP_ACTION", 'try await service.restore(document("B", idle: nil))')+ swift = swift.replace("OVERLAP_ASSERTION", r'''+ expect(snapshot.pronunciationProfiles == ["original"] && snapshot.settings.owner == "B" && snapshot.transcriptionHistory == ["B"], "historical export/import overlap must expose mixed snapshot")+ print("REPRODUCED: old pronunciation + new settings/History from overlapping export/import")+''')+ swift = swift.replace("CURRENT_TESTS", 'print("Historical overlap probe completed")')+ else:+ swift = swift.replace("OVERLAP_ACTION", r'''+ await busy { try await service.restore(document("B", idle: nil)) }+ await busy { _ = try await service.makeBackupDocument() }+ let during = await PronunciationDictionaryStore.shared.state()+ expect(during.2 == 0 && during.1 == 1, "rejected overlap cannot enter profile writer/second snapshot")+ expect(SettingsStore.shared.owner == "original" && TranscriptionHistoryStore.shared.writes == 0 && NotificationCenter.default.snapshots.isEmpty, "rejected import cannot write or notify")+''')+ swift = swift.replace("OVERLAP_ASSERTION", r'''+ expect(snapshot.pronunciationProfiles == [snapshot.settings.owner] && snapshot.transcriptionHistory == [snapshot.settings.owner], "admitted export remains a consistent snapshot")+ try await service.restore(document("B", idle: nil))+ let freshExport = try await service.makeBackupDocument()+ expect(freshExport.pronunciationProfiles == ["B"] && freshExport.settings.owner == "B", "import and export can retry after owner finishes")+''')+ swift = swift.replace("CURRENT_TESTS", r'''+ // Reject complete imports before any profile/settings/history mutation when+ // existing capture, processing, preparation, download or cleanup owns the app.+ for blocker in 0..<21 {+ await reset()+ let asr = AppServices.shared.asr+ switch blocker {+ case 0: _ = try asr.acquireExclusiveActivity(.dictation)+ case 1: _ = try asr.acquireExclusiveActivity(.fileTranscription)+ case 2: _ = try asr.acquireExclusiveActivity(.localAPI)+ case 3: _ = try asr.acquireExclusiveActivity(.meeting)+ case 4: _ = try asr.acquireExclusiveActivity(.modelMaintenance)+ case 5: asr.isRunning = true+ case 6: asr.isStarting = true+ case 7: asr.isStoppingFinalTranscription = true+ case 8: asr.recordingBufferHandoffGate.isRecovering = true+ case 9: asr.isMicrophonePreviewRequested = true+ case 10: asr.isMicrophonePreviewActive = true+ case 11: asr.hasActiveModelDownload = true+ case 12: asr.hasActiveModelPreparation = true+ case 13: asr.deletingModelID = "fixture"+ case 14: asr.providerResetDrain = UUID()+ case 15: asr.isCancellingModelPreparation = true+ case 16: asr.meetingModelResidency.isExclusive = true+ case 17: asr.isAsrReady = false; asr.isLoadingModel = true+ case 18: asr.isCancellingModelDownload = true+ case 19: asr.isTerminating = true+ default: asr.isAsrReady = false; asr.isDownloadingModel = true+ }+ let originalLease = asr.activeActivityLease+ do {+ try await service.restore(document("busy", idle: nil))+ fatalError("Active work must reject the import before any writes")+ } catch ASRActivityError.settingsRestoreUnavailable {+ expect(ASRActivityError.settingsRestoreUnavailable.localizedDescription.contains("import the backup again"), "busy rejection gives an explicit retry")+ }+ let untouched = await PronunciationDictionaryStore.shared.state()+ expect(untouched.2 == 0 && untouched.0 == ["original"], "busy import must not replace profiles")+ expect(SettingsStore.shared.owner == "original" && TranscriptionHistoryStore.shared.history == ["original"] && TranscriptionHistoryStore.shared.writes == 0, "busy import must preserve settings/history")+ expect(NotificationCenter.default.snapshots.isEmpty && asr.activeActivityLease == originalLease, "busy import must not notify or release another activity")+ // No queued automatic import: a fresh explicit retry is required.+ AppServices.shared.asr = ASRService()+ try await service.restore(document("retry", idle: nil))+ expect(SettingsStore.shared.owner == "retry" && AppServices.shared.asr.activeActivityLease == nil, "busy rejection releases backup gate for explicit retry")+ }++ // Reverse overlap: an admitted import has not yet replaced profiles.+ let restoreGate = Gate()+ await reset(restoreGate: restoreGate)+ let firstRestore = Task { try await service.restore(document("A")) }+ await awaitGate(restoreGate)+ let restoringASR = AppServices.shared.asr+ expect(restoringASR.activeExclusiveActivity == .settingsRestore, "import reserves ASR before the profile actor hop")+ for activity: ASRExclusiveActivity in [.dictation, .fileTranscription, .localAPI, .meeting, .modelMaintenance] {+ do {+ _ = try restoringASR.acquireExclusiveActivity(activity)+ fatalError("A new activity must not race into the suspended import")+ } catch ASRActivityError.activityInProgress(let existing) {+ expect(existing == .settingsRestore, "competing activity sees the exact import owner")+ }+ }+ await busy { _ = try await service.makeBackupDocument() }+ await busy { try await service.restore(document("B")) }+ let beforeReplace = await PronunciationDictionaryStore.shared.state()+ expect(beforeReplace.2 == 1 && beforeReplace.1 == 0 && TranscriptionHistoryStore.shared.loads == 0, "reverse overlap is rejected before export load or second profile write")+ await restoreGate.release(); try await firstRestore.value+ expect(restoringASR.activeActivityLease == nil && restoringASR.admissions == 1 && restoringASR.releases == 1, "successful import releases its exact ASR reservation once")+ let nextDictation = try restoringASR.acquireExclusiveActivity(.dictation)+ restoringASR.releaseExclusiveActivity(nextDictation)+ let afterRestore = try await service.makeBackupDocument()+ expect(afterRestore.settings.owner == "A" && afterRestore.pronunciationProfiles == ["A"] && afterRestore.transcriptionHistory == ["A"], "admitted restore publishes one complete document")++ // An unchanged idle preference leaves no await after the UI notification.+ // Observe synchronous reset arming, then queue capture admission before+ // restore returns; it must never observe the old ready-model state.+ await reset()+ let unchangedASR = AppServices.shared.asr+ var queuedCapture: Task<Void, Never>?+ NotificationCenter.default.onPost = {+ expect(unchangedASR.activeExclusiveActivity == .settingsRestore && unchangedASR.providerResetPending, "UI observers run after model retirement is armed while import admission is held")+ queuedCapture = Task { @MainActor in+ expect(!unchangedASR.isAsrReady && unchangedASR.completedResets == 1, "queued capture sees retired ready-model state before admission")+ do {+ let lease = try unchangedASR.acquireExclusiveActivity(.dictation)+ unchangedASR.releaseExclusiveActivity(lease)+ } catch { fatalError("Capture should be retryable after the completed fixture reset") }+ }+ }+ try await service.restore(document("unchanged-idle", idle: 30))+ await queuedCapture?.value+ let unchangedIdle = await PrivateAIIntegrationService.idleUnloader.state()+ expect(unchangedIdle.0 == 0 && unchangedASR.recoveryRequests == 1 && unchangedASR.completedResets == 1, "unchanged idle import arms exactly one reset/recovery without a timer hop")+ expect(!unchangedASR.providerResetPending && unchangedASR.activeActivityLease == nil, "queued capture leaves no stale reset or import reservation")++ // Retain ownership through timer replies and notification reentrancy.+ let idleGate = Gate()+ await reset(idleGate: idleGate)+ let idleRestore = Task { try await service.restore(document("A")) }+ await awaitGate(idleGate)+ await busy { _ = try await service.makeBackupDocument() }+ await busy { try await service.restore(document("B", idle: nil)) }+ expect(NotificationCenter.default.snapshots.count == 1 && NotificationCenter.default.snapshots.allSatisfy { $0.1 == [$0.0] }, "synchronous observers see matching settings/history")+ SettingsStore.shared.privateAIIdleUnload = 0+ idleRestore.cancel(); await idleGate.release(); try await idleRestore.value+ let idleState = await PrivateAIIntegrationService.idleUnloader.state()+ expect(idleState.1 == [0], "timer reads latest user preference after cancellation")+ try await service.restore(document("retry", idle: nil))+ expect(SettingsStore.shared.owner == "retry", "cancellation after commit releases busy flag")++ // Cancel a read-only export while actor reply is delayed: no document or write.+ let cancelledGate = Gate()+ await reset(exportGate: cancelledGate)+ let cancelledExport = Task { try await service.makeBackupDocument() }+ await awaitGate(cancelledGate); cancelledExport.cancel(); await cancelledGate.release()+ do { _ = try await cancelledExport.value; fatalError("Expected cancellation") } catch is CancellationError {}+ expect(SettingsStore.shared.owner == "original" && TranscriptionHistoryStore.shared.writes == 0 && NotificationCenter.default.snapshots.isEmpty, "cancelled export has no writes/notifications")+ _ = try await service.makeBackupDocument()+ try await service.restore(document("after-export-cancel", idle: nil))+ expect(SettingsStore.shared.owner == "after-export-cancel", "cancelled export releases gate for both operations")++ // A profile write admitted before cancellation must finish the matching+ // synchronous commit rather than leave new profiles with old settings.+ let cancelledRestoreGate = Gate()+ await reset(restoreGate: cancelledRestoreGate)+ let cancelledRestore = Task { try await service.restore(document("cancelled", idle: nil)) }+ await awaitGate(cancelledRestoreGate); cancelledRestore.cancel(); await cancelledRestoreGate.release()+ try await cancelledRestore.value+ expect(AppServices.shared.asr.activeActivityLease == nil && AppServices.shared.asr.releases == 1, "cancelled admitted import releases its ASR reservation")+ let completed = try await service.makeBackupDocument()+ expect(completed.pronunciationProfiles == ["cancelled"] && completed.settings.owner == "cancelled" && completed.transcriptionHistory == ["cancelled"], "cancellation after profile admission finishes a consistent restore")+ expect(NotificationCenter.default.snapshots.count == 1, "completed cancelled restore notifies exactly once")++ // Cancellation before admission prevents all dependency work and releases gate.+ for isRestore in [false, true] {+ await reset()+ let task = Task { () throws -> Void in+ withUnsafeCurrentTask { $0?.cancel() }+ if isRestore { try await service.restore(document("unstarted")) }+ else { _ = try await service.makeBackupDocument() }+ }+ do { try await task.value; fatalError("Expected early cancellation") } catch is CancellationError {}+ let untouched = await PronunciationDictionaryStore.shared.state()+ expect(untouched.1 == 0 && untouched.2 == 0 && TranscriptionHistoryStore.shared.loads == 0, "pre-cancelled operation never touches dependencies")+ _ = try await service.makeBackupDocument()+ try await service.restore(document("retry", idle: nil))+ expect(SettingsStore.shared.owner == "retry", "early cancellation clears admission flag")+ }+ // Every failure path releases its hold and preserves non-effects.+ await reset()+ await PronunciationDictionaryStore.shared.setup(reject: true)+ do { try await service.restore(document("failed")); fatalError("Expected store failure") } catch ProbeFailure.storage {}+ expect(SettingsStore.shared.owner == "original" && TranscriptionHistoryStore.shared.writes == 0 && NotificationCenter.default.snapshots.isEmpty, "profile failure has no settings/history/notification effects")+ expect(AppServices.shared.asr.activeActivityLease == nil && AppServices.shared.asr.releases == 1, "profile failure releases the exact ASR reservation")+ await PronunciationDictionaryStore.shared.setup()+ _ = try await service.makeBackupDocument()+ try await service.restore(document("retry", idle: nil))+ expect(SettingsStore.shared.owner == "retry", "profile failure clears gate")+ await reset()+ var invalid = document("invalid"); invalid.schemaVersion = .init(major: 99, minor: 0)+ do { try await service.restore(invalid); fatalError("Expected schema failure") } catch BackupServiceError.unsupportedSchemaVersion {}+ let rejected = await PronunciationDictionaryStore.shared.state()+ expect(rejected.2 == 0 && SettingsStore.shared.owner == "original", "schema validation rejects before profile write")+ _ = try await service.makeBackupDocument()+ expect(TranscriptionHistoryStore.shared.loads == 1, "schema failure clears gate")+ await reset(); TranscriptionHistoryStore.shared.loaded = false+ do { _ = try await service.makeBackupDocument(); fatalError("Expected load failure") } catch ProbeFailure.storage {}+ let unloaded = await PronunciationDictionaryStore.shared.state()+ expect(unloaded.1 == 0 && unloaded.2 == 0 && NotificationCenter.default.snapshots.isEmpty, "load failure has no profile or notification effects")+ TranscriptionHistoryStore.shared.loaded = true+ try await service.restore(document("retry", idle: nil))+ expect(SettingsStore.shared.owner == "retry", "load failure clears gate")++ // Export retains admission even before history has loaded; cancellation+ // is checked after the pre-existing non-cancellable load reply returns.+ let loadGate = Gate()+ await reset(); TranscriptionHistoryStore.shared.loadGate = loadGate+ let loading = Task { try await service.makeBackupDocument() }+ await awaitGate(loadGate)+ await busy { try await service.restore(document("blocked")) }+ await busy { _ = try await service.makeBackupDocument() }+ loading.cancel(); await loadGate.release()+ do { _ = try await loading.value; fatalError("Expected load cancellation") } catch is CancellationError {}+ let noSnapshot = await PronunciationDictionaryStore.shared.state()+ expect(noSnapshot.1 == 0, "cancelled history wait exits before pronunciation snapshot")+ _ = try await service.makeBackupDocument()++ for (idle, expectedCalls) in [(nil, 0), (Optional(30), 0), (Optional(60), 1), (Optional(0), 1)] {+ await reset(); try await service.restore(document("field", idle: idle))+ let state = await PrivateAIIntegrationService.idleUnloader.state()+ expect(state.0 == expectedCalls, "only changed present idle values reschedule")+ expect(SettingsStore.shared.privateAIIdleUnload == (idle ?? 30), "legacy absent idle preserves preference")+ }+ await reset()+ var legacy = document("legacy", idle: nil); legacy.pronunciationProfiles = nil+ try await service.restore(legacy)+ let legacyExport = try await service.makeBackupDocument()+ expect(legacyExport.pronunciationProfiles == [] && legacyExport.settings.owner == "legacy", "legacy import clears newer pronunciation profiles")+ expect(SettingsStore.shared.meetingLanguage == "en" && SettingsStore.shared.configurations == ["__default__": "original"], "absent additive settings remain unchanged")+ var modern = document("modern", idle: nil)+ modern.settings.meetingLanguage = "fr"; modern.settings.promptConfigurations = [:]+ try await service.restore(modern)+ expect(SettingsStore.shared.meetingLanguage == "fr" && SettingsStore.shared.configurations.isEmpty, "present empty configuration remains authoritative")+ await reset()+ NotificationCenter.default.onPost = { SettingsStore.shared.privateAIIdleUnload = 0 }+ try await service.restore(document("notice"))+ let notificationSettings = await PrivateAIIntegrationService.idleUnloader.state()+ expect(notificationSettings.1 == [0], "timer respects synchronous observer preference changes")++ // Deliberately document the limit: ordinary dictionary/settings edits do+ // not participate in BackupService admission. This gate cannot serialize them.+ let manualGate = Gate()+ await reset(exportGate: manualGate)+ let manualExport = Task { try await service.makeBackupDocument() }+ await awaitGate(manualGate)+ await PronunciationDictionaryStore.shared.ordinaryEdit(["manual"])+ SettingsStore.shared.owner = "manual"; TranscriptionHistoryStore.shared.history = ["manual"]+ await manualGate.release()+ let manualSnapshot = try await manualExport.value+ expect(manualSnapshot.pronunciationProfiles == ["original"] && manualSnapshot.settings.owner == "manual", "service gate does not falsely serialize ordinary dictionary/settings mutations")+ expect(AppServices.shared.asr.activeActivityLease == nil, "no completed test leaves import admission held")+ print("LIMIT: ordinary dictionary/settings edits remain outside backup-operation admission")+ print("PASS: \(assertions) production-method concurrency assertions")+''')+ with tempfile.TemporaryDirectory(prefix="fluidvoice-backup-concurrency-") as directory:+ swift_path = Path(directory) / "Probe.swift"+ binary = Path(directory) / "probe"+ swift_path.write_text(swift)+ subprocess.run(["xcrun", "swiftc", "-parse-as-library", str(swift_path), "-o", str(binary)],+ cwd=repo, env=environment, check=True, timeout=60)+ subprocess.run([str(binary)], env=environment, check=True, timeout=20)+++if __name__ == "__main__":+ main()diff --git a/scripts/test_history_presentation.sh b/scripts/test_history_presentation.shindex 2d454184..2b0b58b0 100644--- a/scripts/test_history_presentation.sh+++ b/scripts/test_history_presentation.sh@@ -8,5 +8,6 @@ task_test_dir=$(mktemp -d /tmp/fluidvoice-history-presentation.XXXXXX)# Compile the real value types without starting the app or accessing user history.sed '/^\/\/ MARK: - Transcription History Store/,$d' Sources/Fluid/Persistence/TranscriptionHistoryStore.swift > "$task_test_dir/Entry.swift"sed '/^final nonisolated class DictationAudioHistoryStore/,$d' Sources/Fluid/Persistence/DictationAudioHistoryStore.swift > "$task_test_dir/Audio.swift"-xcrun swiftc -parse-as-library "$task_test_dir/Entry.swift" "$task_test_dir/Audio.swift" Sources/Fluid/UI/HistoryTextDiff.swift Sources/Fluid/UI/HistoryAudioAvailability.swift Sources/Fluid/UI/ModelDisplayName.swift Tests/HistoryPresentationTests.swift -o "$task_test_dir/tests"+sed '/^struct TranscriptionHistoryView:/,$d; s/^import AppKit$/import Foundation/; /^import SwiftUI$/d; /^import UniformTypeIdentifiers$/d' Sources/Fluid/UI/TranscriptionHistoryView.swift > "$task_test_dir/Selection.swift"+xcrun swiftc -parse-as-library "$task_test_dir/Entry.swift" "$task_test_dir/Audio.swift" "$task_test_dir/Selection.swift" Sources/Fluid/UI/HistoryTextDiff.swift Sources/Fluid/UI/HistoryAudioAvailability.swift Sources/Fluid/UI/ModelDisplayName.swift Tests/HistoryPresentationTests.swift -o "$task_test_dir/tests""$task_test_dir/tests"