@hasna/recordings 0.4.0 → 0.5.0

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

@@ -0,0 +1,215 @@
+import Darwin
+import Foundation
+import Testing
+
+/// Test-only observation of the original pipes, independent of transient pre-exec copies.
+enum PipeClosureFixture {
+    static func now() -> UInt64 {
+        var value = timespec()
+        precondition(clock_gettime(CLOCK_MONOTONIC, &value) == 0)
+        return UInt64(value.tv_sec) * 1_000_000_000 + UInt64(value.tv_nsec)
+    }
+
+    static func request(pid: pid_t, deadlineFile: URL) throws -> UInt64 {
+        let deadline = now() + 3_000_000_000
+        try String(deadline).write(to: deadlineFile, atomically: true, encoding: .utf8)
+        try #require(Darwin.kill(pid, SIGUSR1) == 0)
+        return deadline
+    }
+
+    static func marker(at file: URL) -> String? {
+        guard let value = try? String(contentsOf: file, encoding: .utf8), !value.isEmpty else { return nil }
+        return value
+    }
+
+    static func waitForMarker(at file: URL, deadline: UInt64) -> String? {
+        while now() < deadline {
+            if let value = marker(at: file), now() < deadline { return value }
+            Thread.sleep(forTimeInterval: 0.01)
+        }
+        return nil
+    }
+
+    // Shared by both silent-holder fixtures and the deterministic observer controls.
+    // Success is published atomically only when both EPIPE observations are before the
+    // same parent-supplied deadline. Retry the observation, never the command or test.
+    static let observerSource = #"""
+    #include <errno.h>
+    #include <fcntl.h>
+    #include <limits.h>
+    #include <stdint.h>
+    #include <stdio.h>
+    #include <time.h>
+    #include <unistd.h>
+
+    static uint64_t monotonic_ns(void) {
+        struct timespec value;
+        if (clock_gettime(CLOCK_MONOTONIC, &value)) _exit(70);
+        return (uint64_t)value.tv_sec * 1000000000ULL + (uint64_t)value.tv_nsec;
+    }
+
+    static int observePipeClosure(const char *deadlinePath, const char *markerPath,
+        const char *detailsPath, const char *connectedPath, void (*owners)(FILE *, int)) {
+        unsigned long long deadline;
+        FILE *request = fopen(deadlinePath, "r");
+        if (!request) return 71;
+        int parsed = fscanf(request, "%llu", &deadline);
+        fclose(request);
+        if (parsed != 1) return 72;
+        for (int fd = STDOUT_FILENO; fd <= STDERR_FILENO; fd++) {
+            int flags = fcntl(fd, F_GETFL);
+            if (flags < 0 || fcntl(fd, F_SETFL, flags | O_NONBLOCK) < 0) return 73;
+        }
+        ssize_t results[2] = {0, 0}, first[2] = {0, 0};
+        int errors[2] = {0, 0}, firstErrors[2] = {0, 0}, broken[2] = {0, 0};
+        unsigned attempts = 0;
+        uint64_t observedAt = 0;
+        int invalid = 0;
+        while (monotonic_ns() < deadline) {
+            for (int i = 0; i < 2; i++) {
+                if (broken[i]) continue;
+                errno = 0;
+                results[i] = write(STDOUT_FILENO + i, "x", 1);
+                errors[i] = errno;
+                broken[i] = results[i] == -1 && errors[i] == EPIPE;
+                if (results[i] != 1 && !broken[i] &&
+                    !(results[i] == -1 && (errors[i] == EINTR || errors[i] == EAGAIN))) invalid = 1;
+            }
+            observedAt = monotonic_ns();
+            if (attempts++ == 0) {
+                for (int i = 0; i < 2; i++) { first[i] = results[i]; firstErrors[i] = errors[i]; }
+                if (connectedPath && !broken[0] && !broken[1] && !invalid) {
+                    FILE *connected = fopen(connectedPath, "w");
+                    if (!connected) return 74;
+                    fputs("connected", connected);
+                    fclose(connected);
+                }
+            }
+            if (invalid || (broken[0] && broken[1]) || observedAt >= deadline) break;
+            uint64_t remaining = deadline - observedAt;
+            struct timespec delay = {0, (long)(remaining < 10000000 ? remaining : 10000000)};
+            nanosleep(&delay, NULL);
+        }
+        int success = !invalid && broken[0] && broken[1] && observedAt < deadline;
+        FILE *details = detailsPath ? fopen(detailsPath, "w") : NULL;
+        if (details) {
+            fprintf(details, "first_stdout=%ld,errno=%d; first_stderr=%ld,errno=%d; stdout=%ld,errno=%d; stderr=%ld,errno=%d; attempts=%u; observed_ns=%llu; deadline_ns=%llu",
+                (long)first[0], firstErrors[0], (long)first[1], firstErrors[1],
+                (long)results[0], errors[0], (long)results[1], errors[1], attempts,
+                (unsigned long long)observedAt, deadline);
+            if (!success && owners) { owners(details, STDOUT_FILENO); owners(details, STDERR_FILENO); }
+            fclose(details);
+        }
+        char pending[PATH_MAX];
+        int length = snprintf(pending, sizeof(pending), "%s.pending", markerPath);
+        if (length < 0 || length >= (int)sizeof(pending)) return 75;
+        FILE *marker = fopen(pending, "w");
+        if (!marker) return 76;
+        fputs(success ? "both-epipe" : invalid ? "probe-error" : "still-connected", marker);
+        if (fclose(marker) || rename(pending, markerPath)) return 77;
+        return 0;
+    }
+    """#
+}
+
+extension CLIRunnerTests {
+    @Test("pipe closure observer distinguishes transient readers from one persistent reader", arguments: [false, true])
+    func pipeClosureObserverControls(persistentReader: Bool) throws {
+        let root = FileManager.default.temporaryDirectory
+            .appendingPathComponent("recordings-pipe-observer-\(UUID().uuidString)")
+        try FileManager.default.createDirectory(at: root, withIntermediateDirectories: true)
+        defer { try? FileManager.default.removeItem(at: root) }
+        let source = root.appendingPathComponent("observer.c")
+        let executable = root.appendingPathComponent("observer")
+        let ready = root.appendingPathComponent("ready")
+        let deadlineFile = root.appendingPathComponent("deadline")
+        let marker = root.appendingPathComponent("result")
+        let details = root.appendingPathComponent("details")
+        let connected = root.appendingPathComponent("connected")
+        try """
+        #include <signal.h>
+        \(PipeClosureFixture.observerSource)
+        static volatile sig_atomic_t requested = 0;
+        static void requestProbe(int signo) { (void)signo; requested = 1; }
+        int main(int argc, char **argv) {
+            if (argc != 6) return 64;
+            signal(SIGPIPE, SIG_IGN);
+            signal(SIGUSR1, requestProbe);
+            FILE *ready = fopen(argv[1], "w");
+            if (!ready) return 65;
+            fputs("ready", ready);
+            fclose(ready);
+            while (!requested) {
+                struct timespec delay = {0, 1000000};
+                nanosleep(&delay, NULL);
+            }
+            return observePipeClosure(argv[2], argv[3], argv[4], argv[5], NULL);
+        }
+        """.write(to: source, atomically: true, encoding: .utf8)
+        let compile = Process()
+        compile.executableURL = URL(fileURLWithPath: "/usr/bin/cc")
+        compile.arguments = ["-Wall", "-Wextra", "-Werror", "-o", executable.path, source.path]
+        try compile.run()
+        compile.waitUntilExit()
+        try #require(compile.terminationStatus == 0)
+
+        let output = Pipe(), error = Pipe()
+        var leases: [Int32] = []
+        defer {
+            for descriptor in leases where descriptor >= 0 { _ = Darwin.close(descriptor) }
+            for handle in [output.fileHandleForReading, output.fileHandleForWriting,
+                           error.fileHandleForReading, error.fileHandleForWriting] { try? handle.close() }
+        }
+        for pipe in [output, error] {
+            let descriptor = Darwin.fcntl(pipe.fileHandleForReading.fileDescriptor, F_DUPFD_CLOEXEC, 3)
+            try #require(descriptor >= 0)
+            leases.append(descriptor)
+        }
+        let child = Process()
+        child.executableURL = executable
+        child.arguments = [ready.path, deadlineFile.path, marker.path, details.path, connected.path]
+        child.standardOutput = output
+        child.standardError = error
+        try child.run()
+        defer {
+            if child.isRunning { _ = Darwin.kill(child.processIdentifier, SIGKILL) }
+            child.waitUntilExit()
+        }
+        try output.fileHandleForReading.close()
+        try error.fileHandleForReading.close()
+        try output.fileHandleForWriting.close()
+        try error.fileHandleForWriting.close()
+        try #require(PipeClosureFixture.waitForMarker(at: ready, deadline: PipeClosureFixture.now() + 3_000_000_000) == "ready")
+        let deadline = try PipeClosureFixture.request(pid: child.processIdentifier, deadlineFile: deadlineFile)
+        // The observer must actually see retained readers before this test releases
+        // either lease. No delay or scheduling assumption substitutes for that handshake.
+        try #require(PipeClosureFixture.waitForMarker(at: connected, deadline: deadline) == "connected")
+        try #require(Darwin.close(leases[0]) == 0)
+        leases[0] = -1
+        if !persistentReader {
+            try #require(Darwin.close(leases[1]) == 0)
+            leases[1] = -1
+            #expect(PipeClosureFixture.waitForMarker(at: marker, deadline: deadline) == "both-epipe")
+        }
+        // This extra second is only for reaping/reporting the negative control after
+        // its original deadline expires. It cannot admit a late successful observation.
+        while child.isRunning && PipeClosureFixture.now() < deadline + 1_000_000_000 {
+            Thread.sleep(forTimeInterval: 0.01)
+        }
+        try #require(!child.isRunning)
+        child.waitUntilExit()
+        #expect(child.terminationStatus == 0)
+        let observations = try String(contentsOf: details, encoding: .utf8)
+        #expect(observations.contains("first_stdout=1,errno=0; first_stderr=1,errno=0"))
+        if persistentReader {
+            #expect(PipeClosureFixture.now() >= deadline)
+            #expect(PipeClosureFixture.marker(at: marker) == "still-connected")
+            #expect(observations.contains("stdout=-1,errno=\(EPIPE); stderr=1,errno=0"))
+            try #require(Darwin.close(leases[1]) == 0)
+            leases[1] = -1
+            #expect(PipeClosureFixture.marker(at: marker) == "still-connected")
+        } else {
+            #expect(observations.contains("stdout=-1,errno=\(EPIPE); stderr=-1,errno=\(EPIPE)"))
+        }
+    }
+}

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

@@ -27,7 +27,7 @@ struct ProjectStoreTests {
     @Test("legacy app projects migrate to canonical Store ids without losing metadata")
     @MainActor
     func migratesProjectsToCanonicalStore() async throws {
-        let root = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)
+        let root = URL(fileURLWithPath: makeIsolatedTestHome("project-store"), isDirectory: true)
         defer { try? FileManager.default.removeItem(at: root) }
         let bin = root.appendingPathComponent(".bun/bin")
         try FileManager.default.createDirectory(at: bin, withIntermediateDirectories: true)
@@ -80,7 +80,7 @@ struct ProjectStoreTests {
     @Test("duplicate legacy project ids reconcile without crashing or duplicating canonical rows")
     @MainActor
     func duplicateProjectIDsAreDeduplicated() async throws {
-        let root = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)
+        let root = URL(fileURLWithPath: makeIsolatedTestHome("project-store"), isDirectory: true)
         defer { try? FileManager.default.removeItem(at: root) }
         let bin = root.appendingPathComponent(".bun/bin")
         try FileManager.default.createDirectory(at: bin, withIntermediateDirectories: true)
@@ -110,7 +110,7 @@ struct ProjectStoreTests {
     @Test("failed canonical registration preserves recording metadata and can be retried")
     @MainActor
     func failedRegistrationDoesNotDisableCaptureForAppLifetime() async throws {
-        let root = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)
+        let root = URL(fileURLWithPath: makeIsolatedTestHome("project-store"), isDirectory: true)
         defer { try? FileManager.default.removeItem(at: root) }
         let bin = root.appendingPathComponent(".bun/bin")
         try FileManager.default.createDirectory(at: bin, withIntermediateDirectories: true)
@@ -180,7 +180,7 @@ struct ProjectStoreTests {
     @Test("adding a project preserves color in canonical local metadata")
     @MainActor
     func addProjectPreservesColor() async throws {
-        let root = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)
+        let root = URL(fileURLWithPath: makeIsolatedTestHome("project-store"), isDirectory: true)
         defer { try? FileManager.default.removeItem(at: root) }
         let bin = root.appendingPathComponent(".bun/bin")
         try FileManager.default.createDirectory(at: bin, withIntermediateDirectories: true)
@@ -220,7 +220,7 @@ struct ProjectStoreTests {
     @Test("project mutations are rejected while canonical reconciliation is in flight")
     @MainActor
     func serializesReconciliationAndMutations() async throws {
-        let root = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)
+        let root = URL(fileURLWithPath: makeIsolatedTestHome("project-store"), isDirectory: true)
         defer { try? FileManager.default.removeItem(at: root) }
         let bin = root.appendingPathComponent(".bun/bin")
         try FileManager.default.createDirectory(at: bin, withIntermediateDirectories: true)
@@ -257,7 +257,7 @@ struct ProjectStoreTests {
     @Test("project decode failures are visible and prevent readiness")
     @MainActor
     func reportsLoadFailure() async throws {
-        let root = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)
+        let root = URL(fileURLWithPath: makeIsolatedTestHome("project-store"), isDirectory: true)
         defer { try? FileManager.default.removeItem(at: root) }
         try FileManager.default.createDirectory(at: root, withIntermediateDirectories: true)
         let file = root.appendingPathComponent("projects.json")
@@ -280,7 +280,7 @@ struct ProjectStoreTests {
     @Test("unreadable project data blocks every mutation without overwriting the file")
     @MainActor
     func unreadableDataBlocksMutations() async throws {
-        let root = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)
+        let root = URL(fileURLWithPath: makeIsolatedTestHome("project-store"), isDirectory: true)
         defer { try? FileManager.default.removeItem(at: root) }
         try FileManager.default.createDirectory(at: root, withIntermediateDirectories: true)
         let file = root.appendingPathComponent("projects.json")
@@ -310,7 +310,7 @@ struct ProjectStoreTests {
     @Test("a project file that becomes unreadable after launch is never overwritten")
     @MainActor
     func postLaunchReadFailureBlocksMutations() throws {
-        let root = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)
+        let root = URL(fileURLWithPath: makeIsolatedTestHome("project-store"), isDirectory: true)
         defer { try? FileManager.default.removeItem(at: root) }
         try FileManager.default.createDirectory(at: root, withIntermediateDirectories: true)
         let file = root.appendingPathComponent("projects.json")
@@ -334,7 +334,7 @@ struct ProjectStoreTests {
     @Test("external project file changes are never replaced by stale in-memory settings")
     @MainActor
     func externalChangeBlocksMutations() throws {
-        let root = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)
+        let root = URL(fileURLWithPath: makeIsolatedTestHome("project-store"), isDirectory: true)
         defer { try? FileManager.default.removeItem(at: root) }
         try FileManager.default.createDirectory(at: root, withIntermediateDirectories: true)
         let file = root.appendingPathComponent("projects.json")
@@ -354,7 +354,7 @@ struct ProjectStoreTests {
     @Test("a stale app instance cannot overwrite a newer project save")
     @MainActor
     func staleStoreCannotOverwriteNewerSave() throws {
-        let root = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)
+        let root = URL(fileURLWithPath: makeIsolatedTestHome("project-store"), isDirectory: true)
         defer { try? FileManager.default.removeItem(at: root) }
         try FileManager.default.createDirectory(at: root, withIntermediateDirectories: true)
         let file = root.appendingPathComponent("projects.json")

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

@@ -67,7 +67,7 @@ private func makeEngine(
     accessibilityTrusted: Bool = true,
     pasteRecorder: PasteRecorder? = nil
 ) -> RecordingEngine {
-    let engine = RecordingEngine(homePath: makeIsolatedTestHome("delivery-tests"))
+    let engine = RecordingEngine(homePath: makeIsolatedTestHome("delivery-tests"), installsGlobalHandlers: false)
     engine.openAIAPIKeyProvider = { "" }
     engine.microphoneAuthorization = { .denied }
     engine.accessibilityTrustCheck = { accessibilityTrusted }

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

@@ -0,0 +1,50 @@
+import AVFoundation
+import Foundation
+import Testing
+@testable import RecordingsLib
+
+private struct TargetNoopProvider: RecordingTranscriptionProvider {
+    func makeSession(configuration: RecordingProviderSessionConfiguration, onPartialTranscript: @escaping @Sendable (String) -> Void) throws -> any RecordingTranscriptionSession {
+        throw RecordingProviderError.noAudio
+    }
+}
+@MainActor struct RecordingFrozenPasteTargetTests {
+    private let a = PasteApplicationObservation(pid: 90101, bundleIdentifier: "example.editor", launchDate: Date(timeIntervalSince1970: 100), name: "Editor")
+    private let b = PasteApplicationObservation(pid: 90102, bundleIdentifier: "example.notes", launchDate: Date(timeIntervalSince1970: 200), name: "Notes")
+    private func engine() throws -> RecordingEngine {
+        let configuration = try RecordingEngineConfiguration(isolatedHomePath: makeIsolatedTestHome("frozen-target"), preferencesSuiteName: "example.frozen-tests.\(UUID().uuidString)")
+        let engine = RecordingEngine(configuration: configuration, transcriptionProvider: TargetNoopProvider())
+        engine.microphoneAuthorization = { .denied }
+        engine.accessibilityTrustCheck = { false }
+        engine.protectedOperationTrust = { AccessibilityTrustResult(trusted: true, didPrompt: false) }
+        engine.focusedWindowTitleLookup = { _ in nil }
+        engine.selectionCapture = { _ in Issue.record("No Accessibility reads allowed"); return nil }
+        engine.frontmostAppSnapshot = { FrontmostAppSnapshot(pid: ProcessInfo.processInfo.processIdentifier, bundleIdentifier: "example.recorder", launchDate: Date()) }
+        engine.pasteTargetApplicationLookup = { pid in pid == a.pid ? a : b }
+        return engine
+    }
+    private func candidates(_ apps: [PasteApplicationObservation]) -> [PasteTargetCandidate] {
+        apps.map { PasteTargetCandidate(pid: $0.pid, bundleIdentifier: $0.bundleIdentifier, isRegularApp: $0.isRegular, launchDate: $0.launchDate) }
+    }
+    @Test func explicitObservedTargetSurvivesSelfFocusAndLaterAppFocus() throws {
+        let engine = try engine()
+        let target = try #require(RecordingPasteTarget(observation: a, currentPID: ProcessInfo.processInfo.processIdentifier))
+        engine.startRecording(pasteTarget: .frozen(target))
+        let generation = engine.recordingGeneration
+        #expect(engine.resolvePasteTarget(candidates: candidates([a, b]), targetBundleIdentifier: a.bundleIdentifier, targetPid: a.pid, frontmostPid: b.pid, pipelineGeneration: generation)?.pid == a.pid)
+        var reused = a; reused.launchDate = Date(timeIntervalSince1970: 101)
+        #expect(engine.resolvePasteTarget(candidates: candidates([reused, b]), targetBundleIdentifier: a.bundleIdentifier, targetPid: a.pid, frontmostPid: b.pid, pipelineGeneration: generation) == nil)
+        #expect(engine.resolvePasteTarget(candidates: candidates([b]), targetBundleIdentifier: a.bundleIdentifier, targetPid: a.pid, frontmostPid: b.pid, pipelineGeneration: generation) == nil)
+        var helper = a; helper.isRegular = false
+        #expect(engine.resolvePasteTarget(candidates: candidates([helper]), targetBundleIdentifier: a.bundleIdentifier, targetPid: a.pid, frontmostPid: a.pid, pipelineGeneration: generation) == nil)
+    }
+    @Test func explicitNilAndInvalidAtStartNeverAdoptTheFinishTimeApp() throws {
+        for target in [nil, RecordingPasteTarget(observation: a, currentPID: ProcessInfo.processInfo.processIdentifier)] {
+            let engine = try engine(); engine.pasteTargetApplicationLookup = { _ in nil }
+            engine.startRecording(pasteTarget: .frozen(target))
+            #expect(engine.resolvePasteTarget(candidates: candidates([b]), targetBundleIdentifier: nil, targetPid: nil, frontmostPid: b.pid, pipelineGeneration: engine.recordingGeneration) == nil)
+        }
+        let legacy = try engine(); legacy.startRecording()
+        #expect(legacy.resolvePasteTarget(candidates: candidates([b]), targetBundleIdentifier: nil, targetPid: nil, frontmostPid: b.pid, pipelineGeneration: legacy.recordingGeneration)?.pid == b.pid, "Omitting explicit selection preserves the legacy default")
+    }
+}

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

@@ -0,0 +1,48 @@
+import Foundation
+import Testing
+@testable import RecordingsLib
+
+@MainActor struct RecordingPasteTargetTrackerTests {
+    private let a = PasteApplicationObservation(pid: 801, bundleIdentifier: "example.editor", launchDate: Date(timeIntervalSince1970: 100), name: "Editor")
+    private let b = PasteApplicationObservation(pid: 802, bundleIdentifier: "example.notes", launchDate: Date(timeIntervalSince1970: 200), name: "Notes")
+    private let own = PasteApplicationObservation(pid: 900, bundleIdentifier: "example.recorder", launchDate: Date(timeIntervalSince1970: 300))
+
+    @Test func remembersObservedExternalAcrossRecorderActivationAndFreezesValue() throws {
+        var frontmost = a
+        let tracker = RecordingPasteTargetTracker(currentPID: own.pid, frontmost: { frontmost }, lookup: { pid in pid == a.pid ? a : b })
+        frontmost = own; tracker.observe(own)
+        let frozen = try #require(tracker.snapshot())
+        #expect(frozen.processIdentifier == a.pid)
+        #expect(frozen.bundleIdentifier == a.bundleIdentifier)
+        #expect(frozen.launchDate == a.launchDate)
+        frontmost = b; tracker.observe(b)
+        #expect(tracker.snapshot()?.processIdentifier == b.pid)
+        #expect(frozen.processIdentifier == a.pid, "Later focus cannot mutate a capture's value")
+    }
+    @Test func refusesUnobservedSelfNonregularIncompleteAndTerminatedApps() {
+        let tracker = RecordingPasteTargetTracker(currentPID: own.pid, frontmost: { own }, lookup: { _ in a })
+        #expect(tracker.snapshot() == nil)
+        for invalid in [PasteApplicationObservation(pid: 803, bundleIdentifier: "example.helper", launchDate: Date(), isRegular: false),
+                        PasteApplicationObservation(pid: 804, bundleIdentifier: nil, launchDate: Date()),
+                        PasteApplicationObservation(pid: 805, bundleIdentifier: "example.unknown", launchDate: nil),
+                        PasteApplicationObservation(pid: 806, bundleIdentifier: "example.dead", launchDate: Date(), isTerminated: true)] {
+            tracker.observe(invalid); #expect(tracker.snapshot() == nil)
+        }
+    }
+    @Test func refusesPIDReuseAndDoesNotRecoverAnOlderApp() throws {
+        var live = b
+        let tracker = RecordingPasteTargetTracker(currentPID: own.pid, frontmost: { own }, lookup: { _ in live })
+        tracker.observe(a); tracker.observe(b)
+        #expect(tracker.snapshot()?.processIdentifier == b.pid)
+        live.launchDate = Date(timeIntervalSince1970: 201)
+        #expect(tracker.snapshot() == nil)
+        live = b
+        #expect(tracker.snapshot() == nil, "Revalidation failure consumes the remembered destination")
+        tracker.observe(b)
+        var oldIncarnation = b; oldIncarnation.launchDate = Date(timeIntervalSince1970: 199)
+        tracker.terminated(oldIncarnation)
+        #expect(tracker.snapshot() != nil)
+        tracker.terminated(b)
+        #expect(tracker.snapshot() == nil)
+    }
+}

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

@@ -6,27 +6,43 @@ import Testing
 private final class ProviderTestRecorder: PCMRecordingSource, @unchecked Sendable {
     private let lock = NSLock()
     private var callback: (@Sendable (Data) -> Void)?
+    private let stopPCM: Data
     private(set) var stopped = false
+    init(stopPCM: Data = Data()) { self.stopPCM = stopPCM }
     func attach(_ callback: @escaping @Sendable (Data) -> Void) { lock.withLock { self.callback = callback } }
     func emit(_ data: Data) { lock.withLock { callback }?(data) }
     func start() throws {}
-    func stop() { lock.withLock { stopped = true } }
+    func stop() {
+        let delivery = lock.withLock { () -> (@Sendable (Data) -> Void)? in
+            guard !stopped else { return nil }
+            stopped = true
+            return callback
+        }
+        if !stopPCM.isEmpty { delivery?(stopPCM) }
+    }
 }
 
 private final class ProviderTestSession: RecordingTranscriptionSession, @unchecked Sendable {
     private let lock = NSLock()
     private var audio = Data()
+    private var packets: [Data] = []
     private var request: RecordingTranscriptionRequest?
     private var partial: (@Sendable (String) -> Void)?
     private var cancelled = false
+    private var inputEndings: [Data] = []
     private var gate: CheckedContinuation<RecordingProviderResult, Never>?
     let delayFinish: Bool
 
     init(delayFinish: Bool = false) { self.delayFinish = delayFinish }
     var snapshot: (Data, RecordingTranscriptionRequest?, Bool) { lock.withLock { (audio, request, cancelled) } }
+    var endedPCM: [Data] { lock.withLock { inputEndings } }
+    var receivedPackets: [Data] { lock.withLock { packets } }
     func configure(_ partial: @escaping @Sendable (String) -> Void) { lock.withLock { self.partial = partial } }
     func emitPartial(_ text: String) { lock.withLock { partial }?(text) }
-    func appendPCM(_ data: Data) { lock.withLock { if !cancelled { audio.append(data) } } }
+    func appendPCM(_ data: Data) {
+        lock.withLock { if !cancelled { audio.append(data); packets.append(data) } }
+    }
+    func inputEnded() { lock.withLock { if !cancelled { inputEndings.append(audio) } } }
     func finish(_ request: RecordingTranscriptionRequest) async throws -> RecordingProviderResult {
         if delayFinish {
             return await withCheckedContinuation { continuation in
@@ -99,6 +115,7 @@ struct RecordingProviderTests {
         #expect(await eventually { !engine.isTranscribing })
         let request = try #require(session.snapshot.1)
         #expect(session.snapshot.0 == first + tail)
+        #expect(session.endedPCM == [first + tail], "Input ends exactly once after the short tail, before file-based finish")
         #expect(request.duration == Double(6_400) / 48_000)
         let wav = try Data(contentsOf: request.audioURL)
         #expect(String(data: wav.prefix(4), encoding: .utf8) == "RIFF")
@@ -113,6 +130,102 @@ struct RecordingProviderTests {
         #expect(recorder.stopped)
     }
 
+    @Test("A paused provider receives the entire first packet without waiting for a network chunk or Stop",
+          arguments: [2, 1_600, 3_888, 4_800, 4_802])
+    func subChunkPCMReachesProviderBeforeStop(byteCount: Int) async throws {
+        let session = ProviderTestSession()
+        let recorder = ProviderTestRecorder()
+        let engine = try engine(session, recorder: recorder)
+        defer { engine.cancelRecording() }
+        let pcm = Data((0..<byteCount).map { UInt8(truncatingIfNeeded: $0 * 17) })
+        engine.startRecording()
+        recorder.emit(pcm)
+        #expect(await eventually { engine.isRecording })
+        engine.togglePause()
+        recorder.emit(Data(repeating: 9, count: 4_800))
+        #expect(await eventually { session.snapshot.0 == pcm }, "Pause must not withhold a partial network chunk")
+        #expect(session.receivedPackets == [pcm])
+        #expect(session.endedPCM.isEmpty)
+        #expect(session.snapshot.1 == nil)
+
+        engine.stopAndTranscribe()
+        #expect(await eventually { !engine.isTranscribing })
+        let request = try #require(session.snapshot.1)
+        #expect(session.receivedPackets == [pcm], "Stop must not repeat already delivered PCM")
+        #expect(session.endedPCM == [pcm])
+        #expect(Data(try Data(contentsOf: request.audioURL).dropFirst(44)) == pcm)
+        #expect(request.duration == Double(pcm.count) / 48_000)
+    }
+
+    @Test("Pause and resume preserve packet order; an admitted converter tail precedes inputEnded",
+          arguments: [false, true])
+    func orderedPauseResumeAndConverterTail(stopWhilePaused: Bool) async throws {
+        let session = ProviderTestSession()
+        let converterTail = Data([0x10, 0x20, 0x30, 0x40])
+        let recorder = ProviderTestRecorder(stopPCM: converterTail)
+        let engine = try engine(session, recorder: recorder)
+        defer { engine.cancelRecording() }
+        let first = Data(repeating: 1, count: 4_800)
+        let pauseTail = Data(repeating: 2, count: 3_888)
+        let resumed = [Data([3, 4]), Data(repeating: 5, count: 4_798), Data(repeating: 6, count: 9_602)]
+        engine.startRecording()
+        recorder.emit(first)
+        #expect(await eventually { engine.isRecording && session.snapshot.0 == first })
+        recorder.emit(pauseTail)
+        engine.togglePause()
+        recorder.emit(Data(repeating: 9, count: 5_000))
+        #expect(await eventually { session.snapshot.0 == first + pauseTail })
+        #expect(session.receivedPackets == [first, pauseTail])
+        engine.togglePause()
+        recorder.emit(Data())
+        for packet in resumed { recorder.emit(packet) }
+        let beforeStopPackets = [first, pauseTail] + resumed
+        let beforeStopPCM = beforeStopPackets.reduce(into: Data()) { $0.append($1) }
+        #expect(await eventually { session.snapshot.0 == beforeStopPCM })
+        #expect(session.receivedPackets == beforeStopPackets)
+        #expect(session.endedPCM.isEmpty)
+        if stopWhilePaused { engine.togglePause() }
+
+        engine.stopAndTranscribe()
+        #expect(await eventually { !engine.isTranscribing })
+        let request = try #require(session.snapshot.1)
+        let expectedPackets = beforeStopPackets + (stopWhilePaused ? [] : [converterTail])
+        let expectedPCM = expectedPackets.reduce(into: Data()) { $0.append($1) }
+        #expect(session.receivedPackets == expectedPackets)
+        #expect(session.endedPCM == [expectedPCM], "All admitted PCM must arrive exactly once before inputEnded")
+        #expect(Data(try Data(contentsOf: request.audioURL).dropFirst(44)) == expectedPCM)
+        #expect(request.duration == Double(expectedPCM.count) / 48_000)
+        #expect(recorder.stopped)
+    }
+
+    @Test("explicit no-target capture saves transcript and records copy-only non-delivery without AX or a paste")
+    func frozenNoTargetReceipt() async throws {
+        for copied in [true, false] {
+            let session = ProviderTestSession()
+            let recorder = ProviderTestRecorder()
+            let engine = try engine(session, recorder: recorder)
+            engine.autoPasteEnabled = true
+            engine.protectedOperationTrust = { Issue.record("No-target delivery must not request Accessibility"); return AccessibilityTrustResult(trusted: false, didPrompt: false) }
+            var writes: [String] = []
+            engine.pasteFallbackWriter = { text in writes.append(text); return copied }
+            engine.startRecording(pasteTarget: .frozen(nil))
+            recorder.emit(Data(repeating: 1, count: 4_800))
+            #expect(await eventually { engine.isRecording })
+            engine.stopAndTranscribe()
+            #expect(await eventually { engine.recentPastes.count == 1 })
+            let transcript = try #require(engine.recentTranscriptions.first)
+            let receipt = try #require(engine.recentPastes.first)
+            #expect(receipt.captureID == transcript.captureID)
+            #expect(receipt.deliveryStatus == .notDelivered)
+            #expect(!receipt.verified)
+            #expect(receipt.bundleIdentifier == nil)
+            #expect(receipt.appName == "No target app")
+            #expect(receipt.location == (copied ? "Clipboard only" : ""))
+            #expect(writes == ["Spoken words."])
+            #expect(engine.canStartRecording)
+        }
+    }
+
     @Test("cancel during provider finalization drops late text and allows another capture")
     func cancellationDropsStaleCompletions() async throws {
         let session = ProviderTestSession(delayFinish: true)