public import AppKit public import ParcelAnimation public import ParcelConfig public import ParcelCore public import ParcelPlatform import QuartzCore import os @MainActor public final class SystemEngineClock: EngineClock { public init() {} public var now: Double { CACurrentMediaTime() } } @MainActor public final class RunLoopEngineScheduler: EngineScheduler { public init() {} public func schedule(after delay: Double, _ action: @escaping @MainActor () -> Void) -> any EngineCancellation { precondition(delay.isFinite && delay >= 0) let cancellation = ScheduledEngineWork() let work = DispatchWorkItem { [weak cancellation] in MainActor.assumeIsolated { guard let cancellation, !cancellation.cancelled else { return } cancellation.work = nil action() } } cancellation.work = work if delay == 0 { DispatchQueue.main.async(execute: work) } else { DispatchQueue.main.asyncAfter(deadline: .now() + delay, execute: work) } return cancellation } } @MainActor private final class ScheduledEngineWork: EngineCancellation { var work: DispatchWorkItem? var cancelled = false func cancel() { cancelled = true work?.cancel() work = nil } isolated deinit { cancel() } } @MainActor public final class ScreenEngineDisplayLink: NSObject, EngineDisplayLink { private static let logger = Logger(subsystem: "com.parcel", category: "EngineDisplayLink") private let screen: NSScreen private var link: CADisplayLink? private var callback: (@MainActor (Double) -> Void)? private var deliveredFrame = false public var isRunning: Bool { link != nil } public private(set) var frameRate: Double public init(screen: NSScreen) { precondition(screen.maximumFramesPerSecond > 0) self.screen = screen frameRate = Double(screen.maximumFramesPerSecond) } public func start(tick: @escaping @MainActor (Double) -> Void) { guard link == nil else { return } callback = tick deliveredFrame = false let relay = EngineDisplayLinkRelay(owner: self) let link = screen.displayLink(target: relay, selector: #selector(EngineDisplayLinkRelay.tick(_:))) let maximum = Float(screen.maximumFramesPerSecond) link.preferredFrameRateRange = CAFrameRateRange( minimum: min(60, maximum), maximum: maximum, preferred: maximum) self.link = link link.add(to: .main, forMode: .common) let paused = link.isPaused let windows = NSApplication.shared.windows.filter(\.isVisible).count Self.logger.notice("display-link.start paused=\(paused) visible_app_windows=\(windows)") } public func stop() { link?.invalidate() link = nil callback = nil } fileprivate func tick(_ link: CADisplayLink) { if !deliveredFrame { deliveredFrame = true Self.logger.notice("display-link.first-callback") } let interval = link.targetTimestamp - link.timestamp precondition(interval.isFinite && interval > 0) frameRate = 1 / interval ParcelSignposts.displayRefresh(interval: interval) callback?(link.targetTimestamp) } isolated deinit { stop() } } @MainActor private final class EngineDisplayLinkRelay: NSObject { weak var owner: ScreenEngineDisplayLink? init(owner: ScreenEngineDisplayLink) { self.owner = owner } @objc func tick(_ link: CADisplayLink) { owner?.tick(link) } } @MainActor public final class SystemEngineReduceMotionSource: ReduceMotionSource { private var observer: (any NSObjectProtocol)? public init() {} public var isEnabled: Bool { NSWorkspace.shared.accessibilityDisplayShouldReduceMotion } public func start(changed: @escaping @MainActor () -> Void) { stop() observer = NSWorkspace.shared.notificationCenter.addObserver( forName: NSWorkspace.accessibilityDisplayOptionsDidChangeNotification, object: nil, queue: .main ) { _ in Task { @MainActor in changed() } } } public func stop() { if let observer { NSWorkspace.shared.notificationCenter.removeObserver(observer) } observer = nil } isolated deinit { stop() } } @MainActor public final class AccessibilityEngineAnnouncer: EngineAnnouncer { private let localize: @MainActor (Announcement) -> String public init(localize: @escaping @MainActor (Announcement) -> String) { self.localize = localize } public func announce(_ announcement: Announcement) { NSAccessibility.post( element: NSApplication.shared, notification: .announcementRequested, userInfo: [ .announcement: localize(announcement), .priority: NSAccessibilityPriorityLevel.medium.rawValue, ]) } } @MainActor public final class SystemEngineLog: EngineLogSink { private let failures: EngineFailureLogAggregation public convenience init() { let logger = Logger(subsystem: "com.parcel", category: "engine") self.init(clock: SystemEngineClock(), scheduler: RunLoopEngineScheduler()) { message in logger.error("\(message, privacy: .public)") } } package init( clock: any EngineClock, scheduler: any EngineScheduler, interval: Double = 5, output: @escaping @MainActor (String) -> Void ) { failures = EngineFailureLogAggregation(clock: clock, scheduler: scheduler, interval: interval, output: output) } public func record(_ diagnostic: EngineDiagnostic) { failures.record(diagnostic) } public func flush() { failures.flush() } public func forgetFailures(for app: AppID) { failures.forgetFailures(for: app) } } @MainActor public final class SignpostEngineTrace: EngineTraceSink { public let emissionSink: (any ParcelTraceSink)? = SignpostTraceSink.shared public let isEnabled: Bool public nonisolated let detectionSource: (any DetectionTraceSource)? public init(enabled: Bool = ProcessInfo.processInfo.environment["PARCEL_TRACE"] == "1") { isEnabled = enabled detectionSource = enabled ? SignpostDetectionTraceSource() : nil } public func begin(_ stage: EngineTraceStage, transaction: UInt64) { // The emit-only writer owns receipt intervals, including when bookkeeping is disabled. guard isEnabled, stage != .write else { return } ParcelSignposts.beginTransaction(stage.signpost, identifier: transaction) } public func end(_ stage: EngineTraceStage, transaction: UInt64) { guard isEnabled, stage != .write else { return } ParcelSignposts.endTransaction(stage.signpost, identifier: transaction) } } extension EngineTraceStage { var signpost: ParcelTraceName { switch self { case .eventToFirstWrite: .eventToFirstWrite case .eventToSettled: .eventToSettled case .detect: .detect case .apply: .apply case .layout: .layout case .diff: .diff case .reduce: .reduce case .plan: .plan case .write: .write case .settle: .settle } } } @MainActor public final class ConfigStoreEngineSource: EngineConfigurationSource { public let store: ConfigStore private var task: Task? public init(store: ConfigStore) { self.store = store } public func start(changed: @escaping @MainActor (ConfigSnapshot) -> Void) async throws -> ParcelConfiguration { try await store.startWatching() let initial = await store.reload() let updates = await store.updates() task?.cancel() task = Task { @MainActor in for await update in updates { guard !Task.isCancelled else { return } changed(update) } } return initial.activeConfiguration } public func stop() async { let previous = task task = nil previous?.cancel() await previous?.value await store.stopWatching() } isolated deinit { task?.cancel() } }