fix: harden ONNX transcription and update sherpa-onnx to 1.13.7 (#253)

* fix: handle short ONNX audio and update sherpa-onnx

* fix: preserve ONNX pause boundaries and cancellation

Author: Mr-Sunglasses

AGENTS.md

@@ -190,7 +190,7 @@ Version-bump changelog tables go in the **PR description**, not a tracked file.
 |------------|---------|-----|
 | [WhisperKit](https://github.com/argmaxinc/WhisperKit) | Whisper CoreML | `from: "0.9.4"` |
 | [FluidAudio](https://github.com/FluidInference/FluidAudio) | Parakeet CoreML / ANE | `.upToNextMinor(from: "0.15.5")` (pre-1.0) |
-| [sherpa-onnx](https://github.com/k2-fsa/sherpa-onnx) | Specialized ONNX, CPU | revision pin (SPM not in a tagged release; xcframework v1.13.4) |
+| [sherpa-onnx](https://github.com/k2-fsa/sherpa-onnx) | Specialized ONNX, CPU | exact `1.13.7` (matching xcframework) |
 
 Keep dependencies minimal. Do not bump FluidAudio across a minor without checking `AsrManager.loadModels` / TDT decoder APIs.
 

Package.swift

@@ -27,11 +27,10 @@ let package = Package(
         .package(url: "https://github.com/FluidInference/FluidAudio.git", .upToNextMinor(from: "0.15.5")),
         // sherpa-onnx — specialized ONNX models (Moonshine, SenseVoice,
         // GigaAM, Canary) via ONNX Runtime, CPU-only.
-        // Pinned to a revision: the SPM manifest is not in a tagged release
-        // yet; the pinned manifest references the v1.13.4 binary xcframework.
+        // Pin the release and its matching binary xcframework for reproducible builds.
         .package(
             url: "https://github.com/k2-fsa/sherpa-onnx",
-            revision: "00ad9a19a63751a6c4b12050a00eacfeb204814e"
+            exact: "1.13.7"
         ),
     ],
     targets: [
@@ -62,7 +61,8 @@ let package = Package(
         .testTarget(
             name: "VocaMacTests",
             dependencies: ["VocaMac"],
-            path: "Tests/VocaMacTests"
+            path: "Tests/VocaMacTests",
+            exclude: ["Fixtures"]
         )
     ]
 )

Sources/VocaMac/Services/AudioSegmenter.swift

@@ -96,7 +96,10 @@ enum AudioSegmenter {
         guard !energies.isEmpty else { return fallback }
 
         let sorted = energies.sorted()
-        let quietThreshold = sorted[sorted.count / 4]
+        // A percentile alone marks flat/continuous sound as quiet and can
+        // bury short pauses when they occupy less than a quarter of the window.
+        // Require a 10 dB energy drop relative to the louder frames as well.
+        let quietThreshold = min(sorted[sorted.count / 4], sorted[sorted.count * 3 / 4] * 0.1)
 
         var bestStart = 0, bestLength = 0
         var runStart = 0, runLength = 0
@@ -118,7 +121,11 @@ enum AudioSegmenter {
             return frameOffsets[min(middle, frameOffsets.count - 1)] + frameLength / 2
         }
 
-        // No real pause — fall back to the single quietest frame.
+        // With no meaningful energy dip, use the full window instead of
+        // inventing an early boundary in continuous sound.
+        guard let minimum = sorted.first, minimum <= quietThreshold else { return fallback }
+
+        // No sustained pause — fall back to the single quietest frame.
         var quietestIndex = 0
         for (index, energy) in energies.enumerated() where energy < energies[quietestIndex] {
             quietestIndex = index

Sources/VocaMac/Services/LoadSerializer.swift

@@ -19,16 +19,22 @@ actor LoadSerializer {
     /// Run `operation` after every operation queued before it has settled.
     ///
     /// A failure in one operation does not prevent later ones from running;
-    /// the error is delivered to whoever queued that operation.
+    /// the error is delivered to whoever queued that operation. Cancellation
+    /// reaches queued/running work, but it still owns its queue position until
+    /// it finishes. Cleanup can opt out so cancellation cannot skip teardown.
     func run<T: Sendable>(
+        cancellable: Bool = true,
         _ operation: @escaping @Sendable () async throws -> T
     ) async throws -> T {
         let previous = tail
 
         let task = Task<Result<T, Error>, Never> {
             await previous?.value
             do {
-                return .success(try await operation())
+                if cancellable { try Task.checkCancellation() }
+                let value = try await operation()
+                if cancellable { try Task.checkCancellation() }
+                return .success(value)
             } catch {
                 return .failure(error)
             }
@@ -38,7 +44,12 @@ actor LoadSerializer {
         // a thrown error cannot cancel the queue.
         tail = Task { _ = await task.value }
 
-        switch await task.value {
+        let result = await withTaskCancellationHandler {
+            await task.value
+        } onCancel: {
+            if cancellable { task.cancel() }
+        }
+        switch result {
         case .success(let value):
             return value
         case .failure(let error):

Sources/VocaMac/Services/ModelManager.swift

@@ -488,6 +488,7 @@ final class ModelManager {
         size: ModelSize,
         onProgress: @escaping (Double) -> Void
     ) async throws {
+        try Task.checkCancellation()
         guard let spec = SherpaModelCatalog.spec(for: size) else {
             throw ModelManagerError.modelNotAvailable(size.rawValue)
         }
@@ -548,6 +549,11 @@ final class ModelManager {
                 )
             }
 
+            // Cancellation may arrive during hashing/extraction. Stop before
+            // changing the installed model; once the swap begins, finish its
+            // rollback-safe transaction without interruption.
+            try Task.checkCancellation()
+
             // Swap the finished model in without a window where neither copy
             // is in place: move any existing install aside first, and only
             // delete it once the new one has landed.
@@ -588,6 +594,8 @@ final class ModelManager {
 
             onProgress(1.0)
             VocaLogger.info(.modelManager, "ONNX model '\(size.rawValue)' installed at: \(destination.path)")
+        } catch is CancellationError {
+            throw CancellationError()
         } catch {
             VocaLogger.error(.modelManager, "Download failed for '\(size.rawValue)': \(error.localizedDescription)")
             throw ModelManagerError.downloadFailed(reason: error.localizedDescription)
@@ -597,23 +605,27 @@ final class ModelManager {
     /// SHA-256 of a file, read in chunks so a large archive never has to be
     /// held in memory all at once.
     static func sha256Hex(ofFileAt url: URL) throws -> String {
+        try Task.checkCancellation()
         let handle = try FileHandle(forReadingFrom: url)
         defer { try? handle.close() }
 
         var hasher = SHA256()
         while let chunk = try handle.read(upToCount: 1 << 20), !chunk.isEmpty {
+            try Task.checkCancellation()
             hasher.update(data: chunk)
         }
         return hasher.finalize().map { String(format: "%02x", $0) }.joined()
     }
 
     /// Extract a .tar.bz2 archive using the system tar.
     static func extractTarArchive(at archive: URL, into directory: URL) throws {
+        try Task.checkCancellation()
         let process = Process()
         process.executableURL = URL(fileURLWithPath: "/usr/bin/tar")
         process.arguments = ["xjf", archive.path, "-C", directory.path]
         try process.run()
         process.waitUntilExit()
+        try Task.checkCancellation()
         guard process.terminationStatus == 0 else {
             throw ModelManagerError.downloadFailed(
                 reason: "Archive extraction failed (tar exited with \(process.terminationStatus))"

Sources/VocaMac/Services/SherpaAudioPreparation.swift

@@ -0,0 +1,25 @@
+// SherpaAudioPreparation.swift
+// VocaMac
+
+/// Conditions individual 16 kHz segments before they reach native ONNX code.
+/// Very short waveforms can have too few frames for feature extraction or
+/// encoder subsampling. Padding preserves the speech and gives the decoder
+/// trailing context without changing the recording's reported duration.
+enum SherpaAudioPreparation {
+    static let minimumSampleCount = 16_000
+
+    /// Reject malformed input before segmentation or any native inference.
+    static func validate(_ samples: [Float]) throws {
+        guard !samples.isEmpty else { throw SherpaError.emptyAudio }
+        guard samples.allSatisfy({ $0.isFinite }) else {
+            throw SherpaError.transcriptionFailed(reason: "Audio contains non-finite samples.")
+        }
+    }
+
+    static func prepare(_ samples: [Float]) -> [Float] {
+        // Do not ask generative decoders to invent words for digital silence.
+        guard samples.contains(where: { $0 != 0 }) else { return [] }
+        guard samples.count < minimumSampleCount else { return samples }
+        return samples + [Float](repeating: 0, count: minimumSampleCount - samples.count)
+    }
+}