Skip to content

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

31.8 KB
Raw Blame
import AppKit
@testable import FluidVoice_Debug
import XCTest

/// Verifies that temporary Cmd+V payloads are tagged so clipboard managers exclude them
/// from history while the plain-text representation remains available to the paste target.
@MainActor
final class TypingServiceTransientPasteboardTests: XCTestCase {
    func testTemporaryPasteboardWriteCarriesText() {
        let pasteboard = self.makePasteboard()
        defer { pasteboard.releaseGlobally() }

        XCTAssertTrue(
            SystemPasteboardManager(pasteboard: pasteboard)
                .writeTemporaryText("hello world", sessionID: "session")
        )
        XCTAssertEqual(pasteboard.string(forType: .string), "hello world")
    }

    func testTemporaryPasteboardWriteIsMarkedForClipboardManagers() throws {
        let pasteboard = self.makePasteboard()
        defer { pasteboard.releaseGlobally() }

        XCTAssertTrue(
            SystemPasteboardManager(pasteboard: pasteboard)
                .writeTemporaryText("hello world", sessionID: "session")
        )
        let item = try XCTUnwrap(pasteboard.pasteboardItems?.first)
        let transientType = NSPasteboard.PasteboardType("org.nspasteboard.TransientType")
        let autoGeneratedType = NSPasteboard.PasteboardType("org.nspasteboard.AutoGeneratedType")
        let types = item.types.map(\.rawValue)
        XCTAssertTrue(
            types.contains(transientType.rawValue),
            "temporary write must be marked Transient so clipboard managers skip it"
        )
        XCTAssertTrue(
            types.contains(autoGeneratedType.rawValue),
            "temporary write must be marked AutoGenerated so clipboard managers skip it"
        )
        XCTAssertEqual(
            item.data(forType: transientType)?.count,
            0
        )
        XCTAssertEqual(
            item.data(forType: autoGeneratedType)?.count,
            0
        )
    }

    func testTemporaryPasteboardWriteCarriesSourceAndSession() throws {
        let pasteboard = self.makePasteboard()
        defer { pasteboard.releaseGlobally() }

        XCTAssertTrue(
            SystemPasteboardManager(pasteboard: pasteboard)
                .writeTemporaryText("hello world", sessionID: "session")
        )
        let item = try XCTUnwrap(pasteboard.pasteboardItems?.first)
        let sourceType = NSPasteboard.PasteboardType("org.nspasteboard.source")
        let sessionType = NSPasteboard.PasteboardType(
            "\(Bundle.main.bundleIdentifier ?? "com.FluidApp.Fluid").PasteSession"
        )
        XCTAssertEqual(item.string(forType: sourceType), Bundle.main.bundleIdentifier ?? "com.FluidApp.Fluid")
        XCTAssertEqual(item.string(forType: sessionType), "session")
    }

    func testTemporaryPasteboardWriteIsConcealedButStillPasteable() throws {
        let pasteboard = self.makePasteboard()
        defer { pasteboard.releaseGlobally() }

        XCTAssertTrue(
            SystemPasteboardManager(pasteboard: pasteboard)
                .writeTemporaryText("hello world", sessionID: "session")
        )
        let item = try XCTUnwrap(pasteboard.pasteboardItems?.first)
        let types = item.types.map(\.rawValue)
        XCTAssertTrue(
            types.contains("org.nspasteboard.ConcealedType"),
            "temporary dictation must be concealed from clipboard history"
        )
        XCTAssertEqual(item.data(forType: NSPasteboard.PasteboardType("org.nspasteboard.ConcealedType")), Data())
        XCTAssertEqual(item.string(forType: .string), "hello world")
    }

    func testClipboardAuditReportsMarkersWithoutReadingOrChangingPayloads() throws {
        let pasteboard = self.makePasteboard()
        defer { pasteboard.releaseGlobally() }
        let secret = "private-dictation-example-https://private.invalid"
        XCTAssertTrue(SystemPasteboardManager(pasteboard: pasteboard).writeTemporaryText(secret, sessionID: "audit-test"))
        let changeCount = pasteboard.changeCount
        let metadata = ClipboardAudit.metadata(for: pasteboard)
        XCTAssertTrue(metadata.contains("concealed=true"))
        XCTAssertTrue(metadata.contains("transient=true"))
        XCTAssertTrue(metadata.contains("generated=true"))
        XCTAssertTrue(metadata.contains("stable=true"))
        XCTAssertFalse(metadata.contains(secret))
        XCTAssertFalse(metadata.contains("audit-test"))
        XCTAssertEqual(pasteboard.changeCount, changeCount)
        XCTAssertEqual(pasteboard.string(forType: .string), secret)
    }

    func testClipboardShortcutAuditIgnoresOrdinaryTypingAndDoesNotMutateEvents() throws {
        let event = try XCTUnwrap(CGEvent(keyboardEventSource: nil, virtualKey: 8, keyDown: true))
        event.flags = []
        XCTAssertNil(ClipboardAudit.shortcutMetadata(type: .keyDown, event: event))
        event.flags = .maskCommand
        event.setIntegerValueField(.eventSourceUserData, value: 1234)
        let flags = event.flags
        let timestamp = event.timestamp
        let result = try XCTUnwrap(ClipboardAudit.shortcutMetadata(type: .keyDown, event: event))
        XCTAssertTrue(result.contains("keyCode=8"))
        XCTAssertTrue(result.contains("userData=1234"))
        XCTAssertEqual(event.flags, flags)
        XCTAssertEqual(event.timestamp, timestamp)
        XCTAssertEqual(event.getIntegerValueField(.eventSourceUserData), 1234)
        XCTAssertNil(ClipboardAudit.shortcutMetadata(type: .keyUp, event: event))
        event.setIntegerValueField(.keyboardEventKeycode, value: 0)
        XCTAssertNil(ClipboardAudit.shortcutMetadata(type: .keyDown, event: event))
    }

    func testRecoveryActivationDoesNotRaiseAllWindowsOfTargetApp() {
        // Issue #748: recovery must NOT raise every window of the target app.
        let options = TypingService.recoveryActivationOptions

        XCTAssertTrue(
            options.contains(.activateIgnoringOtherApps),
            "recovery must still activate the target app and bring it forward"
        )
        XCTAssertFalse(
            options.contains(.activateAllWindows),
            "Recovery must not raise every window of the target app (issue #748)"
        )
    }

    func testIntentionalClipboardWriteIsHistoryVisible() throws {
        let pasteboard = self.makePasteboard()
        defer { pasteboard.releaseGlobally() }

        XCTAssertTrue(SystemPasteboardManager(pasteboard: pasteboard).writeIntentionalText("keep me"))

        let item = try XCTUnwrap(pasteboard.pasteboardItems?.first)
        let types = item.types.map(\.rawValue)
        XCTAssertEqual(item.string(forType: .string), "keep me")
        XCTAssertFalse(types.contains("org.nspasteboard.TransientType"))
        XCTAssertFalse(types.contains("org.nspasteboard.AutoGeneratedType"))
        XCTAssertFalse(types.contains("org.nspasteboard.ConcealedType"))
        XCTAssertFalse(types.contains { $0.hasSuffix(".PasteSession") })
    }

    func testSnapshotSkipsOversizedRepresentationsButKeepsTheRest() throws {
        let pasteboard = self.makePasteboard()
        defer { pasteboard.releaseGlobally() }
        let hugeType = NSPasteboard.PasteboardType("com.fluidvoice.tests.huge")
        let item = NSPasteboardItem()
        XCTAssertTrue(item.setData(Data(count: SystemPasteboardManager.maximumRepresentationBytes + 1), forType: hugeType))
        XCTAssertTrue(item.setString("keep me", forType: .string))
        XCTAssertTrue(pasteboard.writeObjects([item]))

        let manager = SystemPasteboardManager(pasteboard: pasteboard)
        let snapshot = try XCTUnwrap(manager.captureSnapshot())
        XCTAssertEqual(snapshot.items.count, 1)
        XCTAssertEqual(snapshot.items.first?.representations.map(\.type), [.string])
        XCTAssertTrue(manager.writeTemporaryText("temporary", sessionID: "session"))
        XCTAssertTrue(manager.restore(snapshot))
        XCTAssertEqual(pasteboard.string(forType: .string), "keep me")
        XCTAssertNil(pasteboard.data(forType: hugeType))
    }

    func testSnapshotWithNothingSmallEnoughStillLetsThePasteProceed() throws {
        let pasteboard = self.makePasteboard()
        defer { pasteboard.releaseGlobally() }
        let hugeType = NSPasteboard.PasteboardType("com.fluidvoice.tests.huge")
        let item = NSPasteboardItem()
        XCTAssertTrue(item.setData(Data(count: SystemPasteboardManager.maximumRepresentationBytes + 1), forType: hugeType))
        XCTAssertTrue(pasteboard.writeObjects([item]))

        let manager = SystemPasteboardManager(pasteboard: pasteboard)
        // A nil snapshot would refuse the paste; an empty one must not.
        let snapshot = try XCTUnwrap(manager.captureSnapshot())
        XCTAssertTrue(snapshot.items.isEmpty)
        XCTAssertTrue(manager.writeTemporaryText("temporary", sessionID: "session"))
        XCTAssertTrue(manager.restore(snapshot))
        XCTAssertEqual(pasteboard.string(forType: .string), "temporary")
    }

    func testSnapshotRestoresEveryRepresentation() throws {
        let pasteboard = self.makePasteboard()
        defer { pasteboard.releaseGlobally() }
        let customType = NSPasteboard.PasteboardType("com.fluidvoice.tests.custom")
        let customData = Data([0x01, 0x02, 0x03])
        let originalItem = NSPasteboardItem()
        XCTAssertTrue(originalItem.setString("original", forType: .string))
        XCTAssertTrue(originalItem.setData(customData, forType: customType))
        let secondItem = NSPasteboardItem()
        XCTAssertTrue(secondItem.setString("second", forType: .string))
        XCTAssertTrue(pasteboard.writeObjects([originalItem, secondItem]))
        let originalItems = try XCTUnwrap(pasteboard.pasteboardItems)
        let originalTypes = originalItems.map(\.types)
        let originalRepresentations = originalItems.map { item in
            item.types.map { type in item.data(forType: type) }
        }

        let manager = SystemPasteboardManager(pasteboard: pasteboard)
        let snapshot = try XCTUnwrap(manager.captureSnapshot())
        XCTAssertTrue(manager.writeTemporaryText("temporary", sessionID: "session"))
        XCTAssertTrue(manager.restore(snapshot))

        let restoredItems = try XCTUnwrap(pasteboard.pasteboardItems)
        XCTAssertEqual(restoredItems.count, 2)
        for (restoredItem, sourceTypes) in zip(restoredItems, originalTypes) {
            XCTAssertEqual(Array(restoredItem.types.prefix(sourceTypes.count)), sourceTypes)
            XCTAssertTrue(restoredItem.types.contains(Self.transientType))
            XCTAssertTrue(restoredItem.types.contains(Self.autoGeneratedType))
            XCTAssertFalse(restoredItem.types.contains(NSPasteboard.PasteboardType("org.nspasteboard.ConcealedType")))
        }
        XCTAssertEqual(
            zip(restoredItems, originalTypes).map { item, types in
                types.map { type in item.data(forType: type) }
            },
            originalRepresentations
        )
        let restoredItem = restoredItems[0]
        XCTAssertEqual(restoredItem.string(forType: .string), "original")
        XCTAssertEqual(restoredItem.data(forType: customType), customData)
        XCTAssertEqual(restoredItems[1].string(forType: .string), "second")
    }

    func testSnapshotRestoresImageBeforeTextInOriginalPreferenceOrder() throws {
        let pasteboard = self.makePasteboard()
        defer { pasteboard.releaseGlobally() }

        let bitmap = try XCTUnwrap(
            NSBitmapImageRep(
                bitmapDataPlanes: nil,
                pixelsWide: 2,
                pixelsHigh: 2,
                bitsPerSample: 8,
                samplesPerPixel: 4,
                hasAlpha: true,
                isPlanar: false,
                colorSpaceName: .deviceRGB,
                bytesPerRow: 0,
                bitsPerPixel: 0
            )
        )
        bitmap.setColor(NSColor(deviceRed: 0, green: 0, blue: 1, alpha: 1), atX: 0, y: 0)
        bitmap.setColor(NSColor(deviceRed: 1, green: 0, blue: 0, alpha: 1), atX: 1, y: 0)
        bitmap.setColor(NSColor(deviceRed: 0, green: 1, blue: 0, alpha: 1), atX: 0, y: 1)
        bitmap.setColor(NSColor(deviceRed: 1, green: 1, blue: 1, alpha: 1), atX: 1, y: 1)
        let imageData = try XCTUnwrap(bitmap.representation(using: .tiff, properties: [:]))
        let originalItem = NSPasteboardItem()
        XCTAssertTrue(originalItem.setData(imageData, forType: .tiff))
        XCTAssertTrue(originalItem.setString("image text fallback", forType: .string))
        XCTAssertTrue(pasteboard.writeObjects([originalItem]))
        let originalTypes = try XCTUnwrap(pasteboard.pasteboardItems?.first?.types)
        XCTAssertEqual(originalTypes.first, .tiff)

        let manager = SystemPasteboardManager(pasteboard: pasteboard)
        let snapshot = try XCTUnwrap(manager.captureSnapshot())
        XCTAssertEqual(snapshot.items.first?.representations.map(\.type), originalTypes)
        XCTAssertTrue(manager.writeTemporaryText("temporary", sessionID: "session"))
        XCTAssertTrue(manager.restore(snapshot))

        let restoredItem = try XCTUnwrap(pasteboard.pasteboardItems?.first)
        XCTAssertEqual(Array(restoredItem.types.prefix(originalTypes.count)), originalTypes)
        XCTAssertEqual(restoredItem.data(forType: .tiff), imageData)
        XCTAssertEqual(restoredItem.string(forType: .string), "image text fallback")
        let restoredImageData = try XCTUnwrap(restoredItem.data(forType: .tiff))
        XCTAssertNotNil(NSImage(data: restoredImageData))
    }

    func testSnapshotAddsPortableImageBeforeFilenameForICNSOnlyClipboard() throws {
        let pasteboard = self.makePasteboard()
        defer { pasteboard.releaseGlobally() }

        let bitmap = try XCTUnwrap(
            NSBitmapImageRep(
                bitmapDataPlanes: nil,
                pixelsWide: 2,
                pixelsHigh: 2,
                bitsPerSample: 8,
                samplesPerPixel: 4,
                hasAlpha: true,
                isPlanar: false,
                colorSpaceName: .deviceRGB,
                bytesPerRow: 0,
                bitsPerPixel: 0
            )
        )
        bitmap.setColor(NSColor(deviceRed: 0, green: 0, blue: 1, alpha: 1), atX: 0, y: 0)
        let sourceImageData = try XCTUnwrap(bitmap.representation(using: .png, properties: [:]))
        let icnsType = NSPasteboard.PasteboardType("com.apple.icns")
        let originalItem = NSPasteboardItem()
        XCTAssertTrue(originalItem.setString("Example.icns", forType: .string))
        XCTAssertTrue(originalItem.setData(sourceImageData, forType: icnsType))
        XCTAssertTrue(pasteboard.writeObjects([originalItem]))

        let manager = SystemPasteboardManager(pasteboard: pasteboard)
        let snapshot = try XCTUnwrap(manager.captureSnapshot())
        XCTAssertNotNil(snapshot.items.first?.portableImage)
        XCTAssertTrue(manager.writeTemporaryText("temporary", sessionID: "session"))
        XCTAssertTrue(manager.restore(snapshot))

        let externalReader = NSPasteboard(name: pasteboard.name)
        let restoredItem = try XCTUnwrap(externalReader.pasteboardItems?.first)
        XCTAssertEqual(restoredItem.types.first, .png)
        XCTAssertEqual(restoredItem.string(forType: .string), "Example.icns")
        XCTAssertEqual(restoredItem.data(forType: icnsType), sourceImageData)
        XCTAssertNotNil(restoredItem.data(forType: .png).flatMap(NSImage.init(data:)))
        XCTAssertTrue(restoredItem.types.contains(Self.transientType))
        XCTAssertTrue(restoredItem.types.contains(Self.autoGeneratedType))
    }

    func testSnapshotAddsPortableImageForImageFileURL() throws {
        let pasteboard = self.makePasteboard()
        defer { pasteboard.releaseGlobally() }

        let temporaryDirectory = FileManager.default.temporaryDirectory
            .appendingPathComponent("fluidvoice-image-pasteboard-\(UUID().uuidString)", isDirectory: true)
        try FileManager.default.createDirectory(at: temporaryDirectory, withIntermediateDirectories: true)
        defer { try? FileManager.default.removeItem(at: temporaryDirectory) }

        let bitmap = try XCTUnwrap(
            NSBitmapImageRep(
                bitmapDataPlanes: nil,
                pixelsWide: 1,
                pixelsHigh: 1,
                bitsPerSample: 8,
                samplesPerPixel: 4,
                hasAlpha: true,
                isPlanar: false,
                colorSpaceName: .deviceRGB,
                bytesPerRow: 0,
                bitsPerPixel: 0
            )
        )
        bitmap.setColor(NSColor(deviceRed: 1, green: 0, blue: 0, alpha: 1), atX: 0, y: 0)
        let sourceImageData = try XCTUnwrap(bitmap.representation(using: .png, properties: [:]))
        let imageURL = temporaryDirectory.appendingPathComponent("Example.png")
        try sourceImageData.write(to: imageURL)

        bitmap.setColor(NSColor(deviceRed: 0, green: 0, blue: 1, alpha: 1), atX: 0, y: 0)
        let iconData = try XCTUnwrap(bitmap.representation(using: .png, properties: [:]))
        let icnsType = NSPasteboard.PasteboardType("com.apple.icns")
        let originalItem = NSPasteboardItem()
        XCTAssertTrue(originalItem.setString(imageURL.absoluteString, forType: .fileURL))
        XCTAssertTrue(originalItem.setString("Example.png", forType: .string))
        XCTAssertTrue(originalItem.setData(iconData, forType: icnsType))
        XCTAssertTrue(pasteboard.writeObjects([originalItem]))

        let manager = SystemPasteboardManager(pasteboard: pasteboard)
        let snapshot = try XCTUnwrap(manager.captureSnapshot())
        XCTAssertNotNil(snapshot.items.first?.portableImage)
        XCTAssertTrue(manager.writeTemporaryText("temporary", sessionID: "session"))
        XCTAssertTrue(manager.restore(snapshot))

        let restoredItem = try XCTUnwrap(pasteboard.pasteboardItems?.first)
        XCTAssertEqual(Array(restoredItem.types.prefix(2)), [.fileURL, .png])
        XCTAssertEqual(restoredItem.string(forType: .fileURL), imageURL.absoluteString)
        XCTAssertEqual(restoredItem.data(forType: icnsType), iconData)
        XCTAssertNotEqual(restoredItem.data(forType: .png), iconData)
        XCTAssertEqual(restoredItem.data(forType: .png), sourceImageData)

        let restoredPNG = try XCTUnwrap(restoredItem.data(forType: .png))
        let restoredBitmap = try XCTUnwrap(NSBitmapImageRep(data: restoredPNG))
        let restoredColor = try XCTUnwrap(restoredBitmap.colorAt(x: 0, y: 0)?.usingColorSpace(.deviceRGB))
        XCTAssertGreaterThan(restoredColor.redComponent, 0.8)
        XCTAssertGreaterThan(restoredColor.redComponent, restoredColor.greenComponent + 0.5)
        XCTAssertGreaterThan(restoredColor.redComponent, restoredColor.blueComponent + 0.5)
    }

    func testSnapshotUsesEmbeddedImageWhenImageFileURLCannotBeRead() throws {
        let pasteboard = self.makePasteboard()
        defer { pasteboard.releaseGlobally() }

        let bitmap = try XCTUnwrap(
            NSBitmapImageRep(
                bitmapDataPlanes: nil,
                pixelsWide: 1,
                pixelsHigh: 1,
                bitsPerSample: 8,
                samplesPerPixel: 4,
                hasAlpha: true,
                isPlanar: false,
                colorSpaceName: .deviceRGB,
                bytesPerRow: 0,
                bitsPerPixel: 0
            )
        )
        let iconData = try XCTUnwrap(bitmap.representation(using: .png, properties: [:]))
        let icnsType = NSPasteboard.PasteboardType("com.apple.icns")
        let originalItem = NSPasteboardItem()
        XCTAssertTrue(originalItem.setString("file:///.file/id=123456.789", forType: .fileURL))
        XCTAssertTrue(originalItem.setString("Example.png", forType: .string))
        XCTAssertTrue(originalItem.setData(iconData, forType: icnsType))
        XCTAssertTrue(pasteboard.writeObjects([originalItem]))

        let manager = SystemPasteboardManager(pasteboard: pasteboard)
        let snapshot = try XCTUnwrap(manager.captureSnapshot())
        XCTAssertNotNil(snapshot.items.first?.portableImage)
        XCTAssertTrue(manager.writeTemporaryText("temporary", sessionID: "session"))
        XCTAssertTrue(manager.restore(snapshot))

        let externalReader = NSPasteboard(name: pasteboard.name)
        let restoredItem = try XCTUnwrap(externalReader.pasteboardItems?.first)
        XCTAssertTrue(restoredItem.types.contains(.png))
        XCTAssertLessThan(
            try XCTUnwrap(restoredItem.types.firstIndex(of: .png)),
            try XCTUnwrap(restoredItem.types.firstIndex(of: .string))
        )
        XCTAssertNotNil(restoredItem.data(forType: .png).flatMap(NSImage.init(data:)))
    }

    func testSnapshotDoesNotTurnNonImageFileIconIntoImage() throws {
        let pasteboard = self.makePasteboard()
        defer { pasteboard.releaseGlobally() }

        let bitmap = try XCTUnwrap(
            NSBitmapImageRep(
                bitmapDataPlanes: nil,
                pixelsWide: 1,
                pixelsHigh: 1,
                bitsPerSample: 8,
                samplesPerPixel: 4,
                hasAlpha: true,
                isPlanar: false,
                colorSpaceName: .deviceRGB,
                bytesPerRow: 0,
                bitsPerPixel: 0
            )
        )
        let iconData = try XCTUnwrap(bitmap.representation(using: .png, properties: [:]))
        let icnsType = NSPasteboard.PasteboardType("com.apple.icns")
        let originalItem = NSPasteboardItem()
        XCTAssertTrue(originalItem.setString("file:///tmp/Example.txt", forType: .fileURL))
        XCTAssertTrue(originalItem.setString("Example.txt", forType: .string))
        XCTAssertTrue(originalItem.setData(iconData, forType: icnsType))
        XCTAssertTrue(pasteboard.writeObjects([originalItem]))

        let manager = SystemPasteboardManager(pasteboard: pasteboard)
        let snapshot = try XCTUnwrap(manager.captureSnapshot())
        XCTAssertTrue(manager.writeTemporaryText("temporary", sessionID: "session"))
        XCTAssertTrue(manager.restore(snapshot))

        let restoredItem = try XCTUnwrap(pasteboard.pasteboardItems?.first)
        XCTAssertFalse(restoredItem.types.contains(.png))
        XCTAssertEqual(restoredItem.string(forType: .fileURL), "file:///tmp/Example.txt")
        XCTAssertEqual(restoredItem.data(forType: icnsType), iconData)
    }

    func testLargeRepresentationIsSnapshottedAndRestoredWithoutSizeLimit() throws {
        let pasteboard = self.makePasteboard()
        defer { pasteboard.releaseGlobally() }
        let customType = NSPasteboard.PasteboardType("com.fluidvoice.tests.large")
        let originalData = Data(repeating: 0xab, count: 20 * 1024 * 1024)
        let originalItem = NSPasteboardItem()
        XCTAssertTrue(originalItem.setData(originalData, forType: customType))
        XCTAssertTrue(pasteboard.writeObjects([originalItem]))

        let manager = SystemPasteboardManager(pasteboard: pasteboard)
        let snapshot = try XCTUnwrap(manager.captureSnapshot())
        XCTAssertEqual(snapshot.items.first?.representations.first?.data, originalData)
        XCTAssertTrue(manager.writeTemporaryText("temporary", sessionID: "session"))
        XCTAssertTrue(manager.restore(snapshot))

        XCTAssertEqual(pasteboard.data(forType: customType), originalData)
    }

    func testMoreThanOneHundredItemsAreSnapshottedAndRestored() throws {
        let pasteboard = self.makePasteboard()
        defer { pasteboard.releaseGlobally() }
        let originalItems = (0..<101).map { index in
            let item = NSPasteboardItem()
            XCTAssertTrue(item.setString("item \(index)", forType: .string))
            return item
        }
        XCTAssertTrue(pasteboard.writeObjects(originalItems))

        let manager = SystemPasteboardManager(pasteboard: pasteboard)
        let snapshot = try XCTUnwrap(manager.captureSnapshot())
        XCTAssertEqual(snapshot.items.count, 101)
        XCTAssertTrue(manager.writeTemporaryText("temporary", sessionID: "session"))
        XCTAssertTrue(manager.restore(snapshot))

        let restoredItems = try XCTUnwrap(pasteboard.pasteboardItems)
        XCTAssertEqual(restoredItems.count, 101)
        XCTAssertEqual(restoredItems.first?.string(forType: .string), "item 0")
        XCTAssertEqual(restoredItems.last?.string(forType: .string), "item 100")
    }

    func testCancelledFailedDirectAttemptSuppressesFallbackAndNextDeliveryWorks() {
        var valid = true
        var attempts = [String]()
        let first = TypingService.attemptDirectInsertion(isOutputValid: { valid }) {
            attempts.append("preferred")
            valid = false
            return false
        }
        XCTAssertFalse(first)

        for fallback in ["focused", "accessibility", "hid"] {
            XCTAssertFalse(TypingService.attemptDirectInsertion(isOutputValid: { valid }) {
                attempts.append(fallback)
                return true
            })
        }
        XCTAssertEqual(attempts, ["preferred"])

        valid = true
        XCTAssertTrue(TypingService.attemptDirectInsertion(isOutputValid: { valid }) {
            attempts.append("next delivery")
            return true
        })
        XCTAssertEqual(attempts, ["preferred", "next delivery"])
    }

    func testFailedDirectAttemptKeepsValidFallbackAvailable() {
        var attempts = 0
        XCTAssertFalse(TypingService.attemptDirectInsertion(isOutputValid: { true }) {
            attempts += 1
            return false
        })
        XCTAssertTrue(TypingService.attemptDirectInsertion(isOutputValid: { true }) {
            attempts += 1
            return true
        })
        XCTAssertEqual(attempts, 2)
    }

    func testAXSelectionReplacementNeverErasesSelectionBeforeInsertion() throws {
        let root = URL(fileURLWithPath: #filePath).deletingLastPathComponent().deletingLastPathComponent().deletingLastPathComponent()
        let source = try String(contentsOf: root.appendingPathComponent("Sources/Fluid/Services/TypingService.swift"), encoding: .utf8)
        let start = try XCTUnwrap(source.range(of: "private nonisolated func setTextViaSelection("))
        let end = try XCTUnwrap(source.range(of: "private nonisolated func insertTextAtInsertionPoint", range: start.upperBound..<source.endIndex))
        let selection = String(source[start.lowerBound..<end.lowerBound])
        XCTAssertEqual(selection.components(separatedBy: "AXUIElementSetAttributeValue(").count - 1, 1, "Selection replacement must be a single committed write")
        XCTAssertFalse(selection.contains("\"\" as CFString"), "Never delete the selection before the cancel guard")
        XCTAssertTrue(selection.contains("guard isOutputValid() else { return false }\n        let result = AXUIElementSetAttributeValue(element, kAXSelectedTextAttribute as CFString, cfText)"))
    }

    func testDirectFallbacksAndAXWritesForwardAndRecheckOutputValidity() throws {
        let root = URL(fileURLWithPath: #filePath)
            .deletingLastPathComponent()
            .deletingLastPathComponent()
            .deletingLastPathComponent()
        let source = try String(contentsOf: root.appendingPathComponent("Sources/Fluid/Services/TypingService.swift"), encoding: .utf8)
        let pipelineStart = try XCTUnwrap(source.range(of: "private nonisolated func insertTextDirectly("))
        let pipelineEnd = try XCTUnwrap(source.range(of: "private static let physicalModifierKeys", range: pipelineStart.upperBound..<source.endIndex))
        let pipeline = String(source[pipelineStart.lowerBound..<pipelineEnd.lowerBound])
        XCTAssertEqual(pipeline.components(separatedBy: "Self.attemptDirectInsertion(isOutputValid: isOutputValid").count - 1, 4)
        for dispatch in [
            "insertTextBulkInstant(text, targetPID: preferredTargetPID",
            "insertTextBulkInstant(text, targetPID: focusedPID",
            "insertTextViaAccessibility(text",
            "insertTextBulkHIDInstant(text",
        ] {
            let callStart = try XCTUnwrap(pipeline.range(of: dispatch))
            let callEnd = try XCTUnwrap(pipeline.range(of: "})", range: callStart.upperBound..<pipeline.endIndex))
            XCTAssertTrue(pipeline[callStart.lowerBound..<callEnd.lowerBound].contains("isOutputValid: isOutputValid"))
        }
        let wrapperStart = try XCTUnwrap(source.range(of: "private func insertTextDirectlyOffMain("))
        let wrapperEnd = try XCTUnwrap(source.range(of: "nonisolated static func attemptDirectInsertion", range: wrapperStart.upperBound..<source.endIndex))
        let wrapper = source[wrapperStart.lowerBound..<wrapperEnd.lowerBound]
        XCTAssertTrue(wrapper.contains("isOutputValid: {"))
        XCTAssertTrue(wrapper.contains("DispatchQueue.main.sync { MainActor.assumeIsolated { isOutputValid() } }"))

        let writeStart = try XCTUnwrap(source.range(of: "private nonisolated func insertTextAtCursorUsingSelectedRange("))
        let writes = String(source[writeStart.lowerBound...])
        let lines = writes.components(separatedBy: "\n").map { $0.trimmingCharacters(in: .whitespaces) }
        for (index, line) in lines.enumerated() where line.contains("= AXUIElementSetAttributeValue(") && !line.hasPrefix("_ =") {
            XCTAssertGreaterThan(index, 0)
            XCTAssertEqual(lines[index - 1], "guard isOutputValid() else { return false }")
        }
        XCTAssertTrue(writes.contains("if isOutputValid(), let axRange"))
        XCTAssertTrue(source.contains("guard isOutputValid() else { return -1 }\n                post(keyDown)\n                post(keyUp)"))
    }

    private func makePasteboard() -> NSPasteboard {
        let name = NSPasteboard.Name("com.fluidvoice.tests.transient.\(UUID().uuidString)")
        let pasteboard = NSPasteboard(name: name)
        pasteboard.clearContents()
        return pasteboard
    }

    private static let transientType = NSPasteboard.PasteboardType("org.nspasteboard.TransientType")
    private static let autoGeneratedType = NSPasteboard.PasteboardType("org.nspasteboard.AutoGeneratedType")
}

@MainActor
final class PasteboardOwnershipRegressionTests: XCTestCase {
    func testFailureRestorationPreservesNewerCopy() throws {
        let pasteboard = NSPasteboard.withUniqueName()
        defer { pasteboard.releaseGlobally() }
        pasteboard.setString("original", forType: .string)
        let manager = SystemPasteboardManager(pasteboard: pasteboard)
        let snapshot = try XCTUnwrap(manager.captureSnapshot())
        XCTAssertTrue(manager.writeTemporaryText("dictation", sessionID: "session"))
        pasteboard.clearContents()
        pasteboard.setString("new user copy", forType: .string)
        XCTAssertFalse(manager.restoreTemporarySnapshot(snapshot, sessionID: "session", expectedText: "dictation"))
        XCTAssertEqual(pasteboard.string(forType: .string), "new user copy")
    }

    func testMatchingMarkersDoNotOverrideNewerClipboardGeneration() throws {
        let pasteboard = NSPasteboard.withUniqueName()
        defer { pasteboard.releaseGlobally() }
        pasteboard.setString("original", forType: .string)
        let manager = SystemPasteboardManager(pasteboard: pasteboard)
        let snapshot = try XCTUnwrap(manager.captureSnapshot())
        XCTAssertTrue(manager.writeTemporaryText("dictation", sessionID: "session"))
        let temporary = try XCTUnwrap(pasteboard.pasteboardItems?.first)
        let copy = NSPasteboardItem()
        for type in temporary.types {
            try copy.setData(XCTUnwrap(temporary.data(forType: type)), forType: type)
        }
        pasteboard.clearContents()
        XCTAssertTrue(pasteboard.writeObjects([copy]))
        XCTAssertFalse(manager.isOwned(sessionID: "session", expectedText: "dictation"))
        XCTAssertFalse(manager.restoreTemporarySnapshot(snapshot, sessionID: "session", expectedText: "dictation"))
        XCTAssertEqual(pasteboard.string(forType: .string), "dictation")
    }

    func testUnchangedTemporaryClipboardCanBeRestored() throws {
        let pasteboard = NSPasteboard.withUniqueName()
        defer { pasteboard.releaseGlobally() }
        pasteboard.setString("original", forType: .string)
        let manager = SystemPasteboardManager(pasteboard: pasteboard)
        let snapshot = try XCTUnwrap(manager.captureSnapshot())
        XCTAssertTrue(manager.writeTemporaryText("dictation", sessionID: "session"))
        XCTAssertTrue(manager.restoreTemporarySnapshot(snapshot, sessionID: "session", expectedText: "dictation"))
        XCTAssertEqual(pasteboard.string(forType: .string), "original")
    }
}