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
import Combine
import Foundation
import SQLite3
// These doubles prevent the standalone test executable from touching app audio or settings.
struct DictationAudioMetadata: Codable, Equatable, Sendable {
let fileName: String
let durationMilliseconds: Int
let byteCount: Int
let sampleRate: Int
let channels: Int
let model: String?
}
final class DictationAudioHistoryStore {
static let shared = DictationAudioHistoryStore()
@discardableResult func deleteAudio(fileName: String) -> Int64 { 0 }
func deleteAllAudioFiles() {}
func audioUsageBytes() -> Int64 { 0 }
func deleteUnreferencedAudioFiles(referencedFileNames: Set<String>) -> (fileCount: Int, byteCount: Int64) { (0, 0) }
}
@MainActor final class SettingsStore {
static let shared = SettingsStore()
var audioHistoryBudgetBytes: Int64 { 1_000_000 }
var weekendsDontBreakStreak: Bool { false }
}
final class DebugLogger {
static let shared = DebugLogger()
func info(_ message: String, source: String) {}
func debug(_ message: String, source: String) {}
}
@main struct HistoryPersistenceBoundaryTests {
@MainActor static func main() async throws {
let root = FileManager.default.temporaryDirectory.appendingPathComponent("fluid-history-tests-\(UUID())")
try FileManager.default.createDirectory(at: root, withIntermediateDirectories: true)
defer { try? FileManager.default.removeItem(at: root) }
let suite = "fluid-history-tests-\(UUID())"
guard let defaults = UserDefaults(suiteName: suite) else {
fatalError("Unable to create isolated history defaults")
}
defer { defaults.removePersistentDomain(forName: suite) }
let key = "TranscriptionHistoryEntries"
let audio = DictationAudioMetadata(
fileName: "test.wav",
durationMilliseconds: 1000,
byteCount: 32_000,
sampleRate: 16_000,
channels: 1,
model: "test"
)
let legacy = (0..<8400).map { index in
TranscriptionHistoryEntry(
timestamp: Date(timeIntervalSince1970: Double(index)),
rawText: "Raw \(index)",
processedText: String(repeating: "Test dictation \(index). ", count: 12),
appName: "Test",
windowTitle: "Test",
wasAIProcessed: true,
processingModel: "test",
transcriptionDurationMilliseconds: 50,
aiProcessingDurationMilliseconds: 100,
aiTokensPerSecond: 500,
audio: index == 0 ? audio : nil
)
}
// Simulate history written before stars existed, including legacy backups.
guard var legacyJSON = try JSONSerialization.jsonObject(with: JSONEncoder().encode(legacy)) as? [[String: Any]] else {
preconditionFailure("Expected legacy history to encode as an array of objects")
}
for index in legacyJSON.indices {
legacyJSON[index].removeValue(forKey: "isStarred")
}
try defaults.set(JSONSerialization.data(withJSONObject: legacyJSON), forKey: key)
let url = root.appendingPathComponent("history.sqlite3")
let writer = TranscriptionHistoryWriter(defaults: defaults, url: url)
let store = TranscriptionHistoryStore(writer: writer)
// No actor suspension: these mutations necessarily precede startup loading.
let newID = UUID()
store.addEntry(id: newID, rawText: "new", processedText: "New dictation", appName: "Test", windowTitle: "Test")
store.toggleStar(id: newID)
store.attachAudio(audio, to: newID)
store.deleteEntry(id: legacy[1].id)
try await store.waitUntilLoaded()
await store.waitForTodaySummary()
precondition(store.todaySummary == .init(words: 2, transcriptions: 1), "Startup stats must include merged pending edits")
await store.finishPendingWrites()
precondition(defaults.data(forKey: key) == nil, "Retire legacy only after successful import")
precondition(store.entries.count == 8400)
precondition(store.entries.first(where: { $0.id == newID })?.audio == audio)
precondition(store.entries.first(where: { $0.id == newID })?.isStarred == true)
precondition(store.entries.filter(\.isStarred).count == 1, "Legacy entries must default to unstarred")
precondition(!store.entries.contains(where: { $0.id == legacy[1].id }))
let reloaded = try await TranscriptionHistoryWriter(defaults: defaults, url: url).load()
precondition(reloaded == store.entries, "Migration, metadata and concurrent startup edits must round-trip")
print("PASS: 8,400-entry migration, exact round-trip, startup insert/audio/delete")
// Reject a write touching any old entry. A new dictation and its audio must only update their row.
try self.sql(url, "CREATE TRIGGER reject_old BEFORE INSERT ON history WHEN NEW.id != '\(newID.uuidString)' BEGIN SELECT RAISE(FAIL, 'unrelated row rewritten'); END")
let enqueueStart = ProcessInfo.processInfo.systemUptime
store.attachAudio(audio, to: newID)
store.toggleStar(id: newID)
store.toggleStar(id: newID)
let enqueueMs = (ProcessInfo.processInfo.systemUptime - enqueueStart) * 1000
await store.finishPendingWrites()
await Task.yield()
precondition(store.persistenceError == nil, "Updating one row must not rewrite unrelated history")
let afterStar = try await writer.load()
precondition(afterStar == store.entries, "Rapid star toggles and audio updates must persist in order")
print("PASS: single-row audio update; main actor enqueue \(enqueueMs) ms")
try self.sql(url, "DROP TRIGGER reject_old")
try self.sql(url, "CREATE TRIGGER reject_all BEFORE INSERT ON history BEGIN SELECT RAISE(FAIL, 'test disk failure'); END")
let failedID = UUID()
store.addEntry(id: failedID, rawText: "pending", processedText: "Unsaved", appName: "Test", windowTitle: "Test")
await store.finishPendingWrites()
for _ in 0..<10 {
await Task.yield()
}
precondition(store.persistenceError != nil)
precondition(store.entries.contains(where: { $0.id == failedID }))
await store.waitForTodaySummary()
precondition(store.todaySummary == .init(words: 3, transcriptions: 2), "A disk error must not drop in-memory stats")
let afterFailure = try await writer.load()
precondition(!afterFailure.contains(where: { $0.id == failedID }))
store.retryPersistence()
await store.finishPendingWrites()
let afterFailedReplacement = try await writer.load()
precondition(afterFailedReplacement == afterFailure, "Failed replacement must roll back its initial DELETE")
try self.sql(url, "DROP TRIGGER reject_all")
store.retryPersistence()
await store.finishPendingWrites()
for _ in 0..<10 {
await Task.yield()
}
precondition(store.persistenceError == nil)
let afterRetry = try await writer.load()
precondition(afterRetry.contains(where: { $0.id == failedID }))
print("PASS: failed write stays in memory, surfaces error, retry restores complete snapshot")
store.clearAllHistory()
store.attachAudio(audio, to: newID)
await store.finishPendingWrites()
let afterClear = try await writer.load()
precondition(afterClear.isEmpty, "Late audio must not resurrect deleted entries")
try defaults.set(JSONEncoder().encode(legacy), forKey: key)
let afterRestart = try await TranscriptionHistoryWriter(defaults: defaults, url: url).load()
precondition(afterRestart.isEmpty, "Migration marker must prevent old history resurrection")
print("PASS: clear, late audio, restart and stale legacy cannot resurrect history")
let badURL = root.appendingPathComponent("bad.sqlite3")
let badData = Data("invalid JSON".utf8)
defaults.set(badData, forKey: key)
let badStore = TranscriptionHistoryStore(writer: TranscriptionHistoryWriter(defaults: defaults, url: badURL))
do {
try await badStore.waitUntilLoaded()
preconditionFailure("Corrupt legacy must fail visibly")
} catch {}
precondition(!badStore.isLoading && badStore.persistenceError != nil)
precondition(defaults.data(forKey: key) == badData)
try defaults.set(JSONEncoder().encode([legacy[0]]), forKey: key)
badStore.retryPersistence()
try await badStore.waitUntilLoaded()
precondition(badStore.entries == [legacy[0]])
print("PASS: corrupt migration preserves source, exits loading and supports retry")
let restoreStore = TranscriptionHistoryStore(writer: TranscriptionHistoryWriter(defaults: defaults, url: url))
restoreStore.restore(from: [legacy[3]])
try await restoreStore.waitUntilLoaded()
await restoreStore.finishPendingWrites()
guard let restored = restoreStore.entries.first,
let revision = restored.searchRevision
else { preconditionFailure("Restore must set a search revision") }
precondition(revision > (legacy[3].searchRevision ?? 1), "Restore must invalidate the previous search record")
var expectedRestore = legacy[3]
expectedRestore.searchRevision = revision
precondition(restoreStore.entries == [expectedRestore], "Restore must preserve every field except the search revision")
let afterRestore = try await TranscriptionHistoryWriter(defaults: defaults, url: url).load()
precondition(afterRestore == [expectedRestore], "The new search revision and original content must round-trip")
restoreStore.restore(from: [legacy[3]])
await restoreStore.finishPendingWrites()
guard let nextRevision = restoreStore.entries.first?.searchRevision else {
preconditionFailure("Repeated restore must preserve a search revision")
}
precondition(nextRevision > revision, "Restoring an older backup must advance past the currently indexed revision")
expectedRestore.searchRevision = nextRevision
let afterRepeatedRestore = try await TranscriptionHistoryWriter(defaults: defaults, url: url).load()
precondition(afterRepeatedRestore == [expectedRestore], "Repeated restore changes only the persisted search revision")
print("PASS: restore during loading replaces both memory and disk")
try await self.testTodaySummary(root: root, defaults: defaults, audio: audio)
try await self.testStars(root: root, defaults: defaults, audio: audio)
}
@MainActor static func testStars(root: URL, defaults: UserDefaults, audio: DictationAudioMetadata) async throws {
let url = root.appendingPathComponent("stars.sqlite3")
let writer = TranscriptionHistoryWriter(defaults: defaults, url: url)
let store = TranscriptionHistoryStore(writer: writer)
try await store.waitUntilLoaded()
let older = TranscriptionHistoryEntry(
timestamp: Date(timeIntervalSince1970: 1),
rawText: "Original phrasing",
processedText: "Reusable prompt",
appName: "Editor",
windowTitle: "Reference",
wasAIProcessed: true,
audio: audio,
isStarred: true
)
let newer = TranscriptionHistoryEntry(
timestamp: Date(timeIntervalSince1970: 2),
rawText: "Another prompt",
processedText: "Another prompt",
appName: "Test",
windowTitle: "Test",
wasAIProcessed: false
)
store.restore(from: [older, newer])
precondition(store.search(query: "").map(\.id) == [newer.id, older.id], "Stars must preserve chronological order")
precondition(store.search(query: "", pinnedFirst: true).map(\.id) == [older.id, newer.id], "History displays pins first")
precondition(store.search(query: "prompt", pinnedFirst: true).map(\.id) == [older.id, newer.id], "Pin ordering applies after text filtering")
precondition(store.search(query: "Another", pinnedFirst: true).map(\.id) == [newer.id], "Pins must not bypass the search filter")
let storedOrder = store.entries
let selectedID = store.selectedEntryID
store.toggleStar(id: newer.id)
precondition(store.search(query: "", pinnedFirst: true).map(\.id) == [newer.id, older.id], "Multiple pins retain newest-first order")
store.toggleStar(id: older.id)
precondition(store.search(query: "", pinnedFirst: true).map(\.id) == [newer.id, older.id], "Unpin returns the entry to its date position")
store.toggleStar(id: newer.id)
store.toggleStar(id: older.id)
precondition(store.entries == storedOrder && store.selectedEntryID == selectedID, "Pinning must preserve persisted chronology, all metadata, and selection")
precondition(store.search(query: " ", starredOnly: true).map(\.id) == [older.id])
for query in ["PROMPT", "Original", "Editor", "Reference"] {
precondition(store.search(query: query, starredOnly: true).map(\.id) == [older.id], "Search must intersect with stars across every field")
}
precondition(store.search(query: "Another", starredOnly: true).isEmpty)
precondition(older.replacingAudio(nil).isStarred, "Audio removal must preserve the star")
let backup = try JSONDecoder().decode([TranscriptionHistoryEntry].self, from: JSONEncoder().encode(store.makeBackupPayload()))
store.toggleStar(id: older.id)
await store.finishPendingWrites()
let unstarred = try await writer.load()
precondition(!unstarred.contains(where: \.isStarred), "Removing a star must survive restart")
store.restore(from: backup)
await store.finishPendingWrites()
let restored = try await TranscriptionHistoryWriter(defaults: defaults, url: url).load()
let normalizedRestore = restored.map { entry in
var entry = entry
entry.searchRevision = backup.first(where: { $0.id == entry.id })?.searchRevision
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, deletion and bounded explicit search requests")
}
@MainActor static func testTodaySummary(root: URL, defaults: UserDefaults, audio: DictationAudioMetadata) async throws {
let formatter = ISO8601DateFormatter()
guard var now = formatter.date(from: "2026-03-08T18:00:00Z"),
let losAngeles = TimeZone(identifier: "America/Los_Angeles"),
let plusFourteen = TimeZone(secondsFromGMT: 14 * 3600)
else { preconditionFailure("Invalid calendar fixtures") }
var calendar = Calendar(identifier: .gregorian)
calendar.timeZone = losAngeles
var clockReads = 0
let writer = TranscriptionHistoryWriter(defaults: defaults, url: root.appendingPathComponent("summary.sqlite3"))
let store = TranscriptionHistoryStore(
writer: writer,
summaryNow: {
clockReads += 1
return now
},
summaryCalendar: { calendar }
)
try await store.waitUntilLoaded()
await store.waitForTodaySummary()
guard let day = calendar.dateInterval(of: .day, for: now) else {
preconditionFailure("Missing fixture day")
}
precondition(day.duration == 23 * 3600, "Fixture must exercise a DST-shortened day")
func entry(_ timestamp: Date, _ text: String) -> TranscriptionHistoryEntry {
TranscriptionHistoryEntry(
timestamp: timestamp,
rawText: text,
processedText: text,
appName: "Test",
windowTitle: "Test",
wasAIProcessed: false
)
}
let yesterday = entry(day.start.addingTimeInterval(-1), "not today")
let first = entry(day.start, " one\t two\nthree ")
let last = entry(day.end.addingTimeInterval(-1), "four")
let tomorrow = entry(day.end, "next day")
store.restore(from: [yesterday, first, last, tomorrow])
await store.waitForTodaySummary()
precondition(store.todaySummary == .init(words: 4, transcriptions: 2), "Preserve word splitting and half-open local-day boundaries")
let reads = clockReads
let unchangedEntries = store.entries
for _ in 0..<10_000 {
precondition(store.todaySummary.words == 4)
}
precondition(clockReads == reads, "Rendering must not query clock or schedule a recount")
store.attachAudio(audio, to: first.id)
await store.waitForTodaySummary()
precondition(clockReads == reads, "Audio-only metadata must not invalidate text stats")
precondition(store.entries.map(\.processedText) == unchangedEntries.map(\.processedText))
precondition(store.selectedEntryID == unchangedEntries.first?.id, "Summary work must not change selection")
store.deleteEntry(id: UUID())
store.deleteEntries(ids: [])
await store.waitForTodaySummary()
precondition(clockReads == reads, "No-op deletions must not schedule work")
print("PASS: constant-time stats reads, exact whitespace/DST boundaries, audio-only non-effects")
let additionID = UUID()
store.addEntry(id: additionID, timestamp: now, rawText: "new text", processedText: "new text", appName: "Test", windowTitle: "Test")
store.deleteEntry(id: first.id)
store.deleteEntries(ids: [last.id])
await store.waitForTodaySummary()
precondition(store.todaySummary == .init(words: 2, transcriptions: 1))
store.addEntry(timestamp: now, rawText: "", processedText: " \n ", appName: "Test", windowTitle: "Test")
await store.waitForTodaySummary()
precondition(store.todaySummary == .init(words: 2, transcriptions: 1))
// Bulk replacement followed by rapid changes must only publish the latest history.
store.restore(from: Array(repeating: first, count: 10_000))
await Task.yield()
store.restore(from: [yesterday, first, last, tomorrow])
store.deleteEntries(ids: [first.id, last.id])
await store.waitForTodaySummary()
precondition(store.todaySummary == .init(words: 0, transcriptions: 0), "Never apply a stale bulk-rebuild result")
var replacedFromSubscriber = false
let subscription = store.$todaySummary.sink { summary in
guard summary.words == 3, !replacedFromSubscriber else { return }
replacedFromSubscriber = true
store.restore(from: [yesterday, tomorrow])
}
store.restore(from: [first])
await store.waitForTodaySummary()
precondition(replacedFromSubscriber && store.todaySummary == .init(words: 0, transcriptions: 0), "Reentrant changes must not be lost during publication")
subscription.cancel()
print("PASS: insert/delete/bulk-delete/empty input and rapid replacement converge to latest snapshot")
now = day.end.addingTimeInterval(1)
store.refreshTodaySummaryForCalendarChange()
await store.waitForTodaySummary()
precondition(store.todaySummary == .init(words: 2, transcriptions: 1), "Midnight must refresh without a dictation")
now = day.end.addingTimeInterval(12 * 3600)
calendar.timeZone = plusFourteen
store.refreshTodaySummaryForCalendarChange()
await store.waitForTodaySummary()
precondition(store.todaySummary == .init(words: 0, transcriptions: 0), "Timezone changes must redefine today")
now = yesterday.timestamp
calendar.timeZone = losAngeles
store.refreshTodaySummaryForCalendarChange()
await store.waitForTodaySummary()
precondition(store.todaySummary == .init(words: 2, transcriptions: 1), "Clock moving backward must refresh")
let settledReads = clockReads
store.refreshTodaySummaryForCalendarChange()
await store.waitForTodaySummary()
precondition(clockReads == settledReads + 1, "Activation within same day must not rebuild")
store.clearAllHistory()
await store.waitForTodaySummary()
precondition(store.todaySummary == .init(words: 0, transcriptions: 0))
await store.finishPendingWrites()
print("PASS: day/timezone/backward-clock changes, unchanged-day no-op, and clear")
}
static func sql(_ url: URL, _ command: String) throws {
var handle: OpaquePointer?
precondition(sqlite3_open(url.path, &handle) == SQLITE_OK)
defer { sqlite3_close(handle) }
precondition(sqlite3_exec(handle, command, nil, nil, nil) == SQLITE_OK)
}
}