@hasna/recordings 0.4.0 → 0.5.0

package/src/native/Recordings/RecordingsLib/RecordingProvider.swift

@@ -75,11 +75,16 @@ public protocol RecordingTranscriptionProvider: Sendable {
 }
 
 public protocol RecordingTranscriptionSession: Sendable {
-    /// Called in capture order, in roughly 100 ms chunks, off the audio callback.
+    /// Called in capture order with variable-sized admitted PCM packets, off the audio
+    /// callback. Empty packets are omitted; all admitted packets precede inputEnded().
     /// Return promptly. Providers must bound any queue while connecting or sending.
-    /// The final short chunk is delivered before finish. An in-flight append may race cancel;
-    /// a cancelled session must ignore it.
+    /// An in-flight append may race cancel; a cancelled session must ignore it.
     func appendPCM(_ data: Data)
+    /// Called once after all capture/converter PCM drains, before the fallback WAV is written.
+    /// Streaming providers may close input now and cache an early final result. Return promptly;
+    /// this does not authorize publishing text or reading audioURL before finish is called.
+    /// Must be thread-safe and idempotent, and ignore calls after cancellation.
+    func inputEnded()
     /// Called once after capture drains and the fallback WAV is safely written.
     /// File-based providers may ignore appendPCM and recognize this file locally.
     func finish(_ request: RecordingTranscriptionRequest) async throws -> RecordingProviderResult
@@ -87,6 +92,11 @@ public protocol RecordingTranscriptionSession: Sendable {
     func cancel()
 }
 
+public extension RecordingTranscriptionSession {
+    /// File providers and existing adapters keep their finish-after-WAV behavior.
+    func inputEnded() {}
+}
+
 public enum RecordingProviderError: Error, LocalizedError, Sendable {
     case invalidIsolation
     case noAudio

package/src/native/Recordings/RecordingsTests/BlockingOperationTests.swift

@@ -0,0 +1,85 @@
+import Dispatch
+import Foundation
+import Testing
+@testable import RecordingsLib
+
+@Suite("Blocking operation scheduling")
+struct BlockingOperationTests {
+    private final class Observation: @unchecked Sendable {
+        let entered = DispatchSemaphore(value: 0)
+        let release = DispatchSemaphore(value: 0)
+        let peer = DispatchSemaphore(value: 0)
+        private let lock = NSLock()
+        private var result = (entered: false, peerBeforeRelease: false)
+
+        func record(entered: Bool, peerBeforeRelease: Bool) {
+            lock.lock()
+            result = (entered, peerBeforeRelease)
+            lock.unlock()
+        }
+
+        func snapshot() -> (entered: Bool, peerBeforeRelease: Bool) {
+            lock.lock()
+            defer { lock.unlock() }
+            return result
+        }
+    }
+
+    @Test("blocking work leaves executor progress available and drains after cancellation", arguments: [false, true], [false, true])
+    func peerProgressWhileBlocked(cancel: Bool, delayedSubmission: Bool) async {
+        let observation = Observation()
+        // A single buffered handoff gives the operation its already-created Task handle
+        // without blocking a cooperative worker or capturing an uninitialized variable.
+        let handoff = AsyncStream<Task<(Int, Bool), Never>>.makeStream(bufferingPolicy: .bufferingNewest(1))
+        let work = Task.detached {
+            var handles = handoff.stream.makeAsyncIterator()
+            guard let ownTask = await handles.next() else {
+                preconditionFailure("Fixture task handle was not supplied")
+            }
+            // Admission is deliberately slower than the former two-second entry timer.
+            // Only progress while the synchronous operation is held is under observation.
+            if delayedSubmission { try? await Task.sleep(for: .seconds(3)) }
+            let value = await BlockingOperation.run {
+                observation.entered.signal()
+                // Start the observation inside the operation, after entry. This independent
+                // thread always releases the gate, even when the peer misses its deadline.
+                Thread.detachNewThread {
+                    defer { observation.release.signal() }
+                    let entered = observation.entered.wait(timeout: .now()) == .success
+                    if cancel { ownTask.cancel() }
+                    if entered {
+                        Task.detached { observation.peer.signal() }
+                    }
+                    let progressed = entered && observation.peer.wait(timeout: .now() + .seconds(1)) == .success
+                    observation.record(entered: entered, peerBeforeRelease: progressed)
+                }
+                observation.release.wait()
+                return 7
+            }
+            return (value, Task.isCancelled)
+        }
+        handoff.continuation.yield(work)
+        handoff.continuation.finish()
+        let (value, wasCancelled) = await work.value
+        let observed = observation.snapshot()
+        #expect(observed.entered)
+        #expect(observed.peerBeforeRelease)
+        #expect(value == 7)
+        #expect(wasCancelled == cancel)
+    }
+
+    private enum FixtureFailure: Error { case expected }
+
+    @Test("throwing blocking work preserves its exact error")
+    func preservesError() async {
+        do {
+            let _: Int = try await BlockingOperation.runThrowing(qos: .utility) {
+                throw FixtureFailure.expected
+            }
+            Issue.record("Blocking operation discarded its error")
+        } catch FixtureFailure.expected {
+        } catch {
+            Issue.record("Blocking operation replaced its error: \(error)")
+        }
+    }
+}