package import CoreGraphics package struct AppThreadWindowFrameReadbackReceipt: Sendable { package var frames: [CGWindowID: CGRect] = [:] package var failures: [CGWindowID: any Error] = [:] } package enum AppThreadWindowFrameReadbackError: Error, Sendable, Equatable { case unsettled(CGWindowID) } package enum AppThreadWindowFrameReadback { package static func verified( writes: [AppThreadFrameWrite], receipts: [AppThreadFrameWriteReceipt], pid: pid_t, pause: () async throws -> Void = { try await Task.sleep(for: .milliseconds(20)) }, windows: (CGWindowListOption, CGWindowID) async throws -> [WindowServer.Window], isolation: isolated (any Actor)? = #isolation ) async throws -> AppThreadWindowFrameReadbackReceipt { var pending: [AppThreadFrameWrite] = [] var result = AppThreadWindowFrameReadbackReceipt() let successful = receipts.filter { $0.error == nil && ($0.phase == .final || $0.actual != nil) } var byID: [CGWindowID: AppThreadFrameWriteReceipt] = [:] for receipt in successful { guard byID.updateValue(receipt, forKey: receipt.windowID) == nil else { throw AppThreadFrameWriteError.duplicateWindow(receipt.windowID) } } var seen: Set = [] for write in writes { guard seen.insert(write.windowID).inserted else { throw AppThreadFrameWriteError.duplicateWindow(write.windowID) } guard let receipt = byID[write.windowID] else { continue } if receipt.before == write.target, let actual = receipt.actual { result.frames[write.windowID] = actual } else { pending.append(write) } } let settled = try await settled(writes: pending, pid: pid, pause: pause, windows: windows) result.frames.merge(settled.frames) { _, current in current } result.failures = settled.failures return result } package static func settled( writes: [AppThreadFrameWrite], pid: pid_t, pause: () async throws -> Void = { try await Task.sleep(for: .milliseconds(20)) }, windows: (CGWindowListOption, CGWindowID) async throws -> [WindowServer.Window], isolation: isolated (any Actor)? = #isolation ) async throws -> AppThreadWindowFrameReadbackReceipt { var result = AppThreadWindowFrameReadbackReceipt() guard !writes.isEmpty else { return result } var expected: [CGWindowID: CGRect] = [:] for write in writes { guard expected.updateValue(write.target, forKey: write.windowID) == nil else { throw AppThreadFrameWriteError.duplicateWindow(write.windowID) } } var previous: [CGWindowID: CGRect] = [:] var matches: [CGWindowID: Int] = [:] // Publication follows the AX reply. Suspend the caller, not the app's owning thread. for sample in 0..<6 { try Task.checkCancellation() try await pause() for write in writes where expected[write.windowID] != nil { try Task.checkCancellation() do { let rows = try await windows(.optionIncludingWindow, write.windowID) let frame = try read(windowID: write.windowID, pid: pid) { _, _ in rows } matches[write.windowID] = previous[write.windowID] == frame ? matches[write.windowID, default: 0] + 1 : 0 previous[write.windowID] = frame if frame == write.target || (sample == 5 && matches[write.windowID, default: 0] >= 2) { result.frames[write.windowID] = frame expected.removeValue(forKey: write.windowID) } } catch is CancellationError { throw CancellationError() } catch { result.failures[write.windowID] = error expected.removeValue(forKey: write.windowID) } } if expected.isEmpty { return result } } for id in expected.keys { result.failures[id] = AppThreadWindowFrameReadbackError.unsettled(id) } return result } package static func positionOnlyTarget( desired: CGRect, accepted: CGRect, accessibility: CGRect ) throws -> CGRect? { guard [desired, accepted, accessibility].allSatisfy({ frame in [frame.minX, frame.minY, frame.width, frame.height].allSatisfy(\.isFinite) && frame.width > 0 && frame.height > 0 }) else { throw AppThreadFailure.windowFrame("Invalid geometry for compositor position correction") } guard accepted.origin != desired.origin, accepted.width <= desired.width, accepted.height <= desired.height else { return nil } let origin = CGPoint( x: desired.minX + accessibility.minX - accepted.minX, y: desired.minY + accessibility.minY - accepted.minY) guard origin.x.isFinite, origin.y.isFinite else { throw AppThreadFailure.windowFrame("Compositor position correction exceeded finite coordinates") } return CGRect(origin: origin, size: accessibility.size) } package static func read( windowID: CGWindowID, pid: pid_t, windows: (CGWindowListOption, CGWindowID) throws -> [WindowServer.Window] ) throws -> CGRect { let rows = try windows(.optionIncludingWindow, windowID) guard rows.count <= 1, rows.allSatisfy({ $0.number == windowID }) else { throw AppThreadFailure.windowServer("Expected only CG window \(windowID) in frame readback") } guard let window = rows.first else { throw AppThreadFailure.windowNotFound(windowID) } guard window.pid == pid else { throw AppThreadFailure.windowIdentification( "CG window \(windowID) is owned by PID \(window.pid), not \(pid)") } let frame = window.bounds guard [frame.minX, frame.minY, frame.width, frame.height].allSatisfy(\.isFinite), frame.width > 0, frame.height > 0 else { throw AppThreadFailure.windowFrame("CG window \(windowID) has no usable frame") } return frame } }