import AppKit import ApplicationServices import OSLog import ParcelConfig import ParcelCore import ParcelEngine import ParcelIPC import ParcelPlatform import ParcelUI import ParcelUpdate import ServiceManagement import SwiftUI @MainActor final class NativeAppRuntime: AppRuntime { let services: EngineShellServices let permissions = SystemPermissionProvider() let updater = UpdateController.live() private let store: ConfigStore private let socketPath: String private let instance: SingleInstance private let defaults: UserDefaults private let tourLaunchPolicy: TourLaunchPolicy private let fixtureOnly: Bool private let isolatedStorage: Bool private let workspaceStateStore: WorkspaceStateStore? private let feedbackSensory: FeedbackSensory private let makeWindowWorld: (@MainActor () -> any EngineWindowWorld)? private let makeDisplayLink: (@MainActor (DisplayID) throws -> any EngineDisplayLink)? private var world: RestoringWindowWorld? private var nativeWorld: NativeEngineWorld? private var closingWindows: Set = [] private var inspector: FloatingWindowInspectorController? private lazy var ruleControls = AppRuleControls( settings: settings, engine: { [weak self] in self?.services.engine }, apply: { [weak self] in guard let composition = self?.services.composition else { throw CancellationError() } let result = await composition.reload() guard result.loadState != .rejected, composition.configuration == result.activeConfiguration else { throw AppText.failure("The floating rule could not be applied. Review Settings → Apps.") } }, failure: { [weak self] in self?.services.composition?.report($0) }) private lazy var shortcutEnvironment = AppShortcutEnvironment( nativeWorld: { [weak self] in guard self?.services.engine?.isRunning == true else { return nil } return self?.nativeWorld }, hasPermission: { [weak self] in self?.permissions.status == .granted }) private lazy var settings = SettingsModel( store: store, shortcutChecker: SettingsShortcutChecker( read: { [weak self] in guard let self else { throw CancellationError() } let environment = try await self.shortcutEnvironment.read() self.refreshSystemShortcutReservations(environment) return environment }), commands: services) private let log = AppEngineLog() private lazy var callbackRunner = AppCallbackRunner { [weak self] error in self?.services.composition?.report(error) } private var server: IPCServer? private var shell: ParcelShell? private var hotkeys: HotKeyCenter? var tabView: AppTabView? private var tabViewMinimized: [WindowID: MinimizedWindow] = [:] private var drag: DragMonitor? private var overlays: OverlayController? private var learning: WindowLearningController? private var controls: WindowControlsController? private lazy var hoverFocus = AppHoverFocus( engine: { [weak self] in self?.services.engine }, allowed: { [weak self] in self?.secureInput.isEnabled == false }, failure: { [weak self] in self?.services.composition?.report($0, kind: .input) }) private lazy var dividerHandles = AppDividerHandles( engine: { [weak self] in self?.services.engine }, allowed: { [weak self] in guard let self else { return false } return self.drag?.isRunning == true && !self.secureInput.isEnabled && !self.services.isTourUnresolved }, changed: { [weak self] edge in guard let self else { return } self.overlays?.dividerChanged(edge) self.drag?.publish(self.mouseInputSnapshot, ignoring: self.mousePassthroughWindows) }, failure: { [weak self] in self?.services.composition?.report($0, kind: .input) }) private var feedback: AppFeedback? private let windowActionHints = WindowActionHintController() private var windowActionHintTask: Task? private var windowActionHintTarget: WindowID? private var windowActionHintState: ParcelCore.State? private lazy var secureInput = SecureInputMonitor { [weak self] enabled in self?.secureInputChanged(enabled) } private var learningConfiguration = ParcelConfiguration.defaults private var snapshotTask: Task? private var restorationTask: Task? private var commandTasks: [UUID: Task] = [:] private var hotkeyBindings: AppHotkeys? private var setupShortcuts: AppSetupShortcuts? private var setupMenu: SetupMenuController? private var setupOverlay: SetupLoadingOverlay? private let setupApplications = AppSetupApplications( createsNewInstances: ProcessInfo.processInfo.environment["PARCEL_REALITY"] == "1") private var setupsPrepared = false private lazy var activity = ActivityCollector( store: ActivityStore( fileURL: Self.activityFileURL( configURL: store.fileURL, isolated: fixtureOnly || isolatedStorage || makeWindowWorld != nil))) private lazy var setups = SetupCoordinator( store: SetupStore( fileURL: Self.setupFileURL( configURL: store.fileURL, isolated: fixtureOnly || isolatedStorage || makeWindowWorld != nil)), engine: { [weak self] in self?.services.engine }, launch: { [weak self] bundle in guard let self else { throw CancellationError() } return try await self.setupApplications.launch(bundleID: bundle) }, hide: { [weak self] bundles in guard let self else { throw CancellationError() } return try await self.setupApplications.hideOtherApps(keeping: bundles) }, unhide: { [weak self] bundles in guard let self else { throw CancellationError() } try await self.setupApplications.unhideApps(bundles) }, requireReady: { [weak self] in guard let self else { throw CancellationError() } try self.services.requireTourResolved() }) private let shortcutCapture = AppShortcutCapture() private var hotkeyMode: String? private var voiceOverObservation: VoiceOverObservation? private var voiceOverNoticeShown = false private var systemShortcutKeys: Set = [] private var hotkeyGate = HotkeyDispatchGate() private var effectiveShortcuts: [ConfigCommand: KeyChord]? private var registeredShortcutConfiguration: ParcelConfiguration? private var compositionProblem: MenuProblem? private var updateDeferred = false private var deferredUpdateVersion: String? private lazy var configViewer = AppConfigViewer { [weak self] error in self?.services.composition?.report(error) } private var hotkeyInputFailure: AppInputFailure? private var mouseInputFailure: AppInputFailure? private var highlightPreference = MenuHighlightPreference() private var fixtureOpenAtLogin = false private var desktopSpaces: [NativeDisplaySpaces] = [] private let logger = Logger(subsystem: "dev.vinnymac.parcel", category: "app") init( store: ConfigStore, socketPath: String, defaults: UserDefaults = .standard, fixtureOnly: Bool = false, makeWindowWorld: (@MainActor () -> any EngineWindowWorld)? = nil, makeDisplayLink: (@MainActor (DisplayID) throws -> any EngineDisplayLink)? = nil, workspaceStateStore: WorkspaceStateStore? = nil, isolatedStorage: Bool = false, feedbackSensory: FeedbackSensory = FeedbackSensory(), realitySession: Bool = TourLaunchPolicy.isRealitySession(environment: ProcessInfo.processInfo.environment), firstRunRealitySession: Bool = TourLaunchPolicy.requestsFirstRunReality( environment: ProcessInfo.processInfo.environment) ) { self.store = store self.socketPath = socketPath self.defaults = defaults tourLaunchPolicy = TourLaunchPolicy( defaults: defaults, configFileExists: FileManager.default.fileExists(atPath: store.fileURL.path), realitySession: realitySession, firstRunRealitySession: realitySession && firstRunRealitySession && fixtureOnly && isolatedStorage) services = EngineShellServices( defaults: defaults, tourUnresolved: tourLaunchPolicy.holdsAtLaunch, automaticOffAtLaunch: tourLaunchPolicy.requiresOffAtLaunch) instance = SingleInstance( path: (NSTemporaryDirectory() as NSString).appendingPathComponent("parcel-\(getuid()).app-lock")) self.fixtureOnly = fixtureOnly self.isolatedStorage = isolatedStorage self.workspaceStateStore = workspaceStateStore self.feedbackSensory = feedbackSensory self.makeWindowWorld = makeWindowWorld self.makeDisplayLink = makeDisplayLink updater.availabilityDidChange = { [weak self] in self?.refreshMenuProblem() } log.failure = { [weak self] error, kind in self?.services.composition?.report(error, kind: kind) } permissions.onInputAccessRefreshed = { [weak self] in self?.retryInputInstallation($0) } log.refusal = { [weak self] in self?.overlays?.refused($0) } services.onInputActivityChanged = { [weak self] in self?.refreshInputActivity() } services.overlayActiveAnimations = { [weak self] in self?.overlays?.activeAnimationCount ?? 0 } settings.minimums = SettingsMinimumsModel( read: { [weak self] in guard let engine = self?.services.engine else { throw AppText.failure("Start tiling to inspect learned minimum sizes.") } return engine.learnedMinimums }, reset: { [weak self] bundleID in guard let engine = self?.services.engine else { throw AppText.failure("Start tiling to forget learned minimum sizes.") } try await engine.resetLearnedMinimums(for: bundleID) }) services.privacyPanelCount = { [weak self] in self?.overlays?.privacyPanelCount ?? 0 } services.cleanSpaceBackdropCount = { [weak self] in self?.overlays?.cleanSpaceBackdropCount ?? 0 } services.toggleHoverFocus = { [weak self] in guard let self else { throw AppText.failure("Parcel is shutting down.") } try await self.setHoverFocusEnabled() } services.toggleBorders = { [weak self] in guard let self, let composition = self.services.composition else { throw AppText.failure("Parcel is shutting down.") } let style = self.highlightPreference.toggled(from: composition.configuration.motion.highlight) try await self.settings.setValue(.string(style.rawValue), for: .motion(.highlight)) let snapshot = await composition.reload() guard snapshot.loadState != .rejected, composition.configuration.motion.highlight == style else { throw AppText.failure("Highlight settings could not be applied. Review the configuration in Settings.") } } } func configureLanguage(domain: String, restart: @escaping @MainActor () -> Void) { settings.language = LanguagePreferences(defaults: defaults, domain: domain) settings.language.onRestartRequested = restart #if DEBUG && PARCEL_REALITY services.restartForLanguage = restart #endif } static func allowsRealAppVerification(environment: [String: String]) -> Bool { environment["PARCEL_E2E"] == "1" && environment["PARCEL_E2E_REAL_APPS"] == "1" && environment["PARCEL_E2E_TOKEN"].map { !$0.isEmpty } == true } static func realAppVerificationPIDs(environment: [String: String]) -> Set? { guard allowsRealAppVerification(environment: environment), let raw = environment["PARCEL_E2E_REAL_APP_PIDS"] else { return nil } var result: Set = [] for field in raw.split(separator: ",", omittingEmptySubsequences: false) { guard let pid = Int32(field), pid > 0 else { return [] } result.insert(pid) } return result } func requestTour( afterOnboarding: Bool, alreadyPresented: Bool = false, present: (_ showWelcome: Bool, _ defaultOpenAtLogin: Bool) -> Void ) { guard tourLaunchPolicy.allowsPresentation else { return } if alreadyPresented { present(afterOnboarding, false) return } if afterOnboarding { do { let saved = try TourSetupProgressStore(defaults: defaults).load() guard saved?.shouldPresentAtLaunch ?? tourLaunchPolicy.shouldPresentAtLaunch else { return } } catch { services.composition?.report(error) } } services.holdForTour() present(afterOnboarding, afterOnboarding && tourLaunchPolicy.allowsLoginDefault) } func claimInstance() throws -> Bool { try instance.claim() } func releaseInstance() { instance.release() } func resetBrightness() async throws { let result = try await OverlayBrightnessRecovery().recoverIfNeeded() if result == .unverified { logger.info("Brightness recovery is unverified; the recovery marker remains for the next launch.") } } func permissionGranted() async -> Bool { await permissions.refreshPermission() return permissions.status == .granted } func permissionUpdates() -> AsyncStream { permissions.permissionUpdates() } func startEngine(configuration: ParcelConfiguration) async throws { applyAppearance(configuration.appearance) if let restorationTask { try await restorationTask.value } if services.engine?.isRunning == true { return } logger.notice("Engine starting; tour hold=\(self.services.isTourUnresolved).") let realApps = Self.allowsRealAppVerification(environment: ProcessInfo.processInfo.environment) let realAppPIDs = Self.realAppVerificationPIDs(environment: ProcessInfo.processInfo.environment) let native = NativeEngineWorld { [fixtureOnly] application in if fixtureOnly, let realAppPIDs { return realAppPIDs.contains(application.processIdentifier) } return !fixtureOnly || realApps || application.executableURL?.lastPathComponent == "FixtureApp" } nativeWorld = makeWindowWorld == nil ? native : nil services.awaitTourDiscovery = { [weak self] in guard let self else { throw TourSetupFailure.unavailable } guard self.makeWindowWorld == nil else { return } guard let world = self.nativeWorld else { throw TourSetupFailure.unavailable } try await world.prepareTourDiscovery() } services.tourSkippedApplications = { [weak self] in self?.nativeWorld?.discoverySkippedApplications ?? [] } let world = RestoringWindowWorld( base: makeWindowWorld?() ?? native, existingWindows: { try await Task.detached { Set(try WindowServer().windows().map { WindowID(rawValue: $0.number) }) }.value }, displayFrames: { let top = NSScreen.screens.first?.frame.maxY ?? 0 return NSScreen.screens.map { Rect(x: $0.frame.minX, y: top - $0.frame.maxY, width: $0.frame.width, height: $0.frame.height) } }, confirmedFocus: { [weak self] in self?.learning?.confirmFocus($0) }) self.world = world let startupWindowIDs: @Sendable () async throws -> Set = { try await Task.detached { Set(try WindowServer().windows().map { WindowID(rawValue: $0.number) }) }.value } let engine = try ParcelEngine( world: world, clock: SystemEngineClock(), scheduler: RunLoopEngineScheduler(), displayLink: makeDisplayLink ?? { [native] in try native.displayLink(for: $0) }, announcer: AppAnnouncer( allowsLayoutNotice: { [weak self] announcement in guard let self, let engine = self.services.engine else { return false } return self.services.allowsLayoutNotice(announcement, state: engine.snapshot.state) }, onModeChange: { [weak self] in _ = self?.synchronizeMode() }), log: log, configuration: configuration, minimumSizeStore: makeWindowWorld == nil ? Self.minimumStore(configURL: store.fileURL, fixtureOnly: fixtureOnly || isolatedStorage) : nil, workspaceStateStore: workspaceStateStore, ruleSpaceMoveStore: makeWindowWorld == nil ? RuleSpaceMoveStore( fileURL: Self.minimumStore(configURL: store.fileURL, fixtureOnly: fixtureOnly || isolatedStorage) .fileURL .deletingLastPathComponent().appendingPathComponent("rule-space-moves.json")) : nil, startupWindowIDs: makeWindowWorld == nil ? startupWindowIDs : nil) services.engine = engine prepareActivity(configuration) engine.activity = activity engine.onAlwaysFloat = { [weak self] window in guard let self else { throw CancellationError() } try await self.ruleControls.alwaysFloat(window) } engine.onUndoLastRule = { [weak self] in guard let self else { throw CancellationError() } try await self.ruleControls.undoLastRule() } engine.onFailure = { [weak self] error in if error is SetupOperationError { self?.services.composition?.report(AppFailure(message: error.localizedDescription)) } else { self?.services.composition?.report(error, kind: .internalFailure) } } callbackRunner.applyConfiguration(configuration.callbacks) callbackRunner.start() engine.onCallback = { [weak self] invocation in self?.callbackRunner.submit(invocation) } prepareFeedback() feedback?.controller.update(state: engine.snapshot.state, configuration: configuration.motion, active: true) engine.onReport = { [weak self] report, state in guard let self, self.services.allowsLayoutNotice(report) else { return } do { try self.feedback?.controller.receive(report, state: state) } catch { self.services.composition?.report(error, kind: .feedback) } } engine.onSystemWindowConflictChanged = { [weak self, weak engine] _ in guard let self, let engine else { return } self.services.publish(engine.snapshot) } engine.setWaitingForTour(services.isTourUnresolved) engine.setAutomaticTilingEnabled(services.isAutomaticTilingEnabled) try await engine.start() logger.notice("Engine running; tour hold=\(engine.isWaitingForTour).") await prepareSetups() updateOverlays(configuration) learningConfiguration = configuration await prepareLearning() try prepareControls() refreshLearning() let snapshots = engine.snapshots() snapshotTask = Task { @MainActor [weak self] in var changes = AppSnapshotChanges() var namedSpaces: [DisplayID: SpaceID]? var namedDisplays: [DisplayID]? for await snapshot in snapshots { guard !Task.isCancelled, let self else { return } if let tabView = self.tabView { tabView.observe( snapshot.state, minimized: Set(self.nativeWorld?.minimizedWindows.map { $0.window.id } ?? [])) } _ = self.synchronizeMode() self.services.publish(snapshot, settings: self.settings) self.setups.updateState(snapshot.state) self.shell?.showSuspensionStatus(Self.suspensionStatus(snapshot)) do { try self.synchronizeHoverFocus() } catch { self.services.composition?.report(error, kind: .input) } let displays = snapshot.state.displays.keys.sorted() if self.nativeWorld != nil, namedSpaces != snapshot.state.activeSpaces || namedDisplays != displays { namedSpaces = snapshot.state.activeSpaces namedDisplays = displays do { self.desktopSpaces = try await NativeSpaceReader().snapshot() } catch { self.desktopSpaces = [] self.services.composition?.report(error) } } self.feedback?.controller.update( state: snapshot.state, configuration: self.learningConfiguration.motion, active: engine.isRunning && engine.systemWindowConflict == nil && !self.services.isTourUnresolved) self.learning?.update( state: engine.presentationState, configuration: self.learningConfiguration, active: engine.isRunning && engine.isAutomaticTilingEnabled) self.controls?.update( state: engine.presentationState, configuration: self.learningConfiguration, active: engine.isRunning && engine.systemWindowConflict == nil && !self.services.isTourUnresolved) do { for topic in changes.receive(snapshot) { try await self.server?.publish( IPCEvent(topic: topic, data: .object(["revision": .string(String(snapshot.revision))]))) } } catch { self.logger.error( "IPC snapshot publication failed: \(error.localizedDescription, privacy: .public)") } } } settings.refreshShortcutWarnings() logger.info("Engine started.") } func applyConfiguration(_ configuration: ParcelConfiguration) throws { highlightPreference.observe(configuration.motion.highlight) applyAppearance(configuration.appearance) try services.engine?.applyConfiguration(configuration) prepareActivity(configuration) callbackRunner.applyConfiguration(configuration.callbacks) learningConfiguration = configuration hoverFocus.cancel() try synchronizeHoverFocus() publishMouseInput() if hotkeyBindings != nil { _ = refreshHotkeys(configuration, mode: services.engine?.snapshot.state.activeMode) } else { refreshLearning() } updateOverlays(configuration) if let engine = services.engine { feedback?.controller.update( state: engine.snapshot.state, configuration: configuration.motion, active: engine.isRunning && engine.systemWindowConflict == nil && !services.isTourUnresolved) } } func applyAppearance(_ configuration: AppearanceConfiguration) { OverlayPaletteSource.shared.configure(configuration) let name: NSAppearance.Name? switch configuration.mode { case .system: name = nil case .light: name = .aqua case .dark: name = .darkAqua } guard NSApplication.shared.appearance?.name != name else { return } if let name { guard let appearance = NSAppearance(named: name) else { preconditionFailure("Required macOS appearance unavailable") } NSApplication.shared.appearance = appearance } else { NSApplication.shared.appearance = nil } } private func updateOverlays(_ configuration: ParcelConfiguration) { services.composition?.clearNotice(.dimming) if !configuration.motion.enabled { services.composition?.clearNotice(.motion) } guard let engine = services.engine, engine.isRunning else { overlays?.stop() overlays = nil return } if let overlays { overlays.update( configuration: configuration.motion, accessibility: .system, focusModes: configuration.focusModes) } else { let overlays = OverlayController(configuration: configuration.motion, focusModes: configuration.focusModes) { [weak self] error in let kind: AppNotices.Kind = error is OverlayWindowReadError ? .highlights : (error as? OverlayBrightnessError) == .verificationFailed ? .dimming : .brightness self?.services.composition?.report(error, kind: kind) } overlays.inspectionWindow = { [weak self] in self?.world?.inspectionWindow($0) } if nativeWorld != nil { overlays.observedFocusedWindow = { [weak self] in self?.nativeWorld?.observedFocusedWindow } nativeWorld?.onWindowObservation = { [weak overlays] observation in switch observation { case .windowsChanged: overlays?.refreshPrivacyWindows() case .frameChanged(let frame): overlays?.observePrivacyFrame(frame) } } } overlays.onDimmingNoticeCleared = { [weak self] in self?.services.composition?.clearNotice(.dimming) } overlays.onSessionSuspended = { [weak engine] in guard let engine else { return } engine.send(.sessionSuspended(Set(engine.snapshot.state.displays.keys))) } overlays.start(snapshots: engine.snapshots()) self.overlays = overlays } } func languageRestartFailed(_ error: any Error) { settings.language.restartFailed(error) } func startIPC() async throws { guard server == nil else { return } let handler = AppIPCHandler( services: services, configPath: store.fileURL.path, setups: setups, settingsAudit: { [weak self] in guard let self, self.fixtureOnly else { throw AppText.failure("The Settings audit is only available in the fixture-only e2e app.") } return try await self.auditSettings() }, fixtureKeyInput: { [weak self] request in guard let self, self.fixtureOnly else { throw AppFixtureDrag.rejected( "Synthetic keyboard input is only available to the fixture-only e2e app") } return try await self.postFixtureKey(request) }, fixtureHoverInput: { [weak self] arguments in guard let self, self.fixtureOnly, let engine = self.services.engine, let controls = self.controls else { throw AppFixtureDrag.rejected("Fixture hover controls are unavailable") } try await AppFixtureHoverInput.post( arguments: arguments, state: engine.presentationState, controller: controls.hover) }, fixtureStackInput: { [weak self] arguments in guard let self, self.fixtureOnly, let engine = self.services.engine, let controls = self.controls else { throw AppFixtureDrag.rejected("Fixture stack controls are unavailable") } try await AppFixtureStackInput.post( arguments: arguments, state: engine.presentationState, controller: controls.chips) }, feedback: { [weak self] arguments in guard let feedback = self?.feedback else { throw AppText.failure("Parcel is shutting down.") } return try await feedback.run(arguments) }, secureInput: { [weak self] in self?.secureInput.refresh() == true }, highlightAudit: { [weak self] in guard let self, self.fixtureOnly, ProcessInfo.processInfo.environment["PARCEL_E2E"] == "1", let overlays = self.overlays else { throw AppText.failure("Parcel is not tiling right now.") } return try JSONDecoder().decode(JSONValue.self, from: JSONEncoder().encode(overlays.highlightAudit())) }, tour: { [weak self] arguments in guard let self, self.fixtureOnly || AppTourIntegration.permitsRealDesktopStatus(arguments) else { throw TourSetupFailure.unavailable } guard let learning = self.learning, let composition = self.services.composition else { if arguments == ["status"] { throw IPCError( code: "tour_unavailable", message: TourSetupFailure.unavailable.localizedDescription) } throw TourSetupFailure.unavailable } if arguments == ["resume-on-launch"] { var progress = try TourSetupProgressStore(defaults: self.defaults).migrate() progress.step = .ready progress.disposition = .inProgress progress.recovery = .interrupted try TourSetupProgressStore(defaults: self.defaults).save(progress) try self.services.persistTourOff() return .object(["accepted": .bool(true)]) } do { return try await AppTourIntegration.fixtureAction( arguments, controller: learning, notices: composition.notices, noticeIsVisible: { self.feedback?.controller.isVisible == true }, currentNotice: { self.feedback?.controller.model.current }, skippedApplications: services.tourSkippedApplications) } catch TourSetupFailure.unavailable where arguments == ["status"] { throw IPCError( code: "tour_unavailable", message: TourSetupFailure.unavailable.localizedDescription) } }, menuAction: { [weak self] arguments in guard let self else { throw AppFixtureMenuFailure(stage: .runtime) } try await self.performFixtureMenuAction(arguments) }, languagePreferences: settings.language, permission: { [permissions] in permissions.status == .granted }) let server = try IPCServer(handler: handler, socketPath: socketPath) { [weak self] error in Task { @MainActor in self?.logger.error("IPC client failed: \(error.localizedDescription, privacy: .public)") } } try await server.start() self.server = server logger.notice("IPC listening at \(self.socketPath, privacy: .public).") } func registerHotkeys(_ configuration: ParcelConfiguration) throws -> [ConfigCommand: KeyChord] { systemShortcutKeys = try Self.systemShortcutReservations( shortcutsEnabled: configuration.general.shortcutsEnabled, current: systemShortcutKeys, read: { try SymbolicHotKeys.read() }) if !configuration.general.shortcutsEnabled { tabView?.cancel(immediately: true) } secureInput.start() if hotkeyBindings == nil { let center = HotKeyCenter( onPress: { [weak self] press in guard let self, self.permitsHotkey(press), !self.synchronizeMode() else { return } if let id = self.setupShortcuts?.action(for: press) { do { let chord = try SettingsShortcutChecker.chord(press.hotKey) if self.shortcutCapture.consume( press, chord: chord, record: self.settings.recordRegisteredShortcut) { return } } catch { self.services.composition?.report(error, kind: .input) return } self.dispatch { try await self.setups.open(id) } return } guard let action = self.hotkeyBindings?.action(for: press) else { return } do { let chord = try SettingsShortcutChecker.chord(press.hotKey) if self.shortcutCapture.consume( press, chord: chord, record: self.settings.recordRegisteredShortcut) { return } } catch { self.services.composition?.report(error, kind: .input) return } if action == .command(.windowControls) { if self.controls?.hover.focusControls() != true { self.services.composition?.report(HoverActionError.unavailableWindow) } return } if action == .command(.tabView) { do { try self.openTabView(press) } catch let error as InputError { self.services.composition?.report(error, kind: .input) } catch { self.services.composition?.report(error) } return } guard let ticket = self.hotkeyGate.begin(action) else { return } self.dispatch { defer { self.hotkeyGate.finish(action) } try Task.checkCancellation() guard self.permitsHotkey(press), !self.synchronizeMode(), self.hotkeyGate.allows(ticket) else { return } switch action { case .command(let command): self.learning?.performed(.keyboard(command)) try await self.services.send(command, activitySource: .keyboard) case .enterMode(let name): try self.services.requireTourResolved() guard let engine = self.services.engine else { throw AppText.failure("Accessibility access is required before tiling can start.") } _ = try await engine.perform(.enterMode(name)) case .exitMode: try self.services.requireTourResolved() guard let engine = self.services.engine else { throw AppText.failure("Accessibility access is required before tiling can start.") } _ = try await engine.perform(.enterMode(nil)) } } }, onFailure: { [weak self] error in guard let self else { return } guard let failure = self.inputFailure(error) else { self.services.composition?.report(error, kind: .hotkeys) return } self.hotkeyInputFailure = failure if self.registeredShortcutConfiguration != nil { _ = self.refreshShortcutPresentation() } self.publishInputFailure() }, isEventTapInputAllowed: { [weak self] in self?.secureInput.refresh(checkOwner: false) == false }, isActive: { [weak self] in self?.acceptsHotkeyInput == true }, onCarbonPress: { [weak self] in _ = self?.secureInput.refresh(checkOwner: false) }, onRepeatedTapTimeout: { [weak self] _ in self?.services.composition?.report(InputError.tapTimedOut, kind: .tapStalls) }) hotkeys = center setupShortcuts = AppSetupShortcuts( register: { _ = try center.register($0, repeats: false) }, unregister: { try center.unregister($0) }, isRegistered: { center.isRegistered($0) }, isReserved: { [weak self] key in self?.systemShortcutKeys.contains(key) == true || (VoiceOverStatus.isRunning && key.conflictsWithVoiceOver) }) tabView = AppTabView(hotkeys: center) { [weak self] window, minimized in self?.chooseTabViewWindow(window, minimized: minimized) } hotkeyBindings = AppHotkeys( register: { key, repeats in _ = try center.register(key, repeats: repeats) }, registerSwitcher: { key, repeats in _ = try center.register(key, repeats: repeats, switcher: true) }, unregister: { try center.unregister($0) }, updateRepeats: { center.updateRepeats($0, enabled: $1) }, registrationIsPresent: { center.isRegistered($0) }, isReserved: { [weak self] chord in self?.systemShortcutKeys.contains(Self.hotkey(chord)) == true }) } observeVoiceOver() return refreshHotkeys(configuration, mode: services.engine?.snapshot.state.activeMode) } var acceptsHotkeyInput: Bool { services.engine?.isRunning == true && !services.isTourUnresolved && (services.engine?.configuration.general.shortcutsEnabled ?? false) } private func observeVoiceOver() { guard voiceOverObservation == nil else { return } voiceOverObservation = VoiceOverStatus.observeChanges { [weak self] in self?.refreshInputActivity() } } private func refreshInputActivity() { if let engine = services.engine { feedback?.controller.update( state: engine.snapshot.state, configuration: learningConfiguration.motion, active: engine.isRunning && engine.systemWindowConflict == nil && !services.isTourUnresolved) } hotkeyGate.invalidate() do { try hotkeys?.refreshActivity() } catch { services.composition?.report(error, kind: .hotkeys) } if registeredShortcutConfiguration != nil { _ = refreshShortcutPresentation() } updateVoiceOverNotice() settings.refreshShortcutWarnings() reloadSetupShortcuts() } private func updateVoiceOverNotice() { let configuration = services.engine?.configuration ?? registeredShortcutConfiguration ?? .defaults let chords = Array(configuration.keybindings.values) + Array(configuration.defaultModeEntries.values) + configuration.modes.values.flatMap { $0.values } let conflicts = VoiceOverStatus.isRunning && chords.contains { Self.hotkey($0).conflictsWithVoiceOver } guard conflicts else { services.composition?.clearNotice(.voiceOver) return } guard !voiceOverNoticeShown, services.composition != nil else { return } voiceOverNoticeShown = true services.composition?.report(AppFailure(message: AppNotices.Kind.voiceOver.message), kind: .voiceOver) } private func permitsHotkey(_ press: HotKeyPress) -> Bool { secureInput.refresh(checkOwner: false) return hotkeys?.isAvailable(press.hotKey) == true } @discardableResult private func synchronizeMode() -> Bool { let mode = services.engine?.snapshot.state.activeMode shell?.setActiveMode(mode) guard hotkeyBindings != nil, hotkeyMode != mode, let configuration = services.engine?.configuration else { return false } _ = refreshHotkeys(configuration, mode: mode) return true } static func systemShortcutReservations( shortcutsEnabled: Bool, current: Set, read: () throws -> [SymbolicHotKey]? ) rethrows -> Set { guard shortcutsEnabled, let entries = try read() else { return current } return Set(entries.filter(\.isEnabled).compactMap(\.hotKey)) } private func refreshSystemShortcutReservations(_ environment: SettingsShortcutEnvironment) { let updated = Self.systemShortcutReservations( shortcutsEnabled: true, current: systemShortcutKeys, read: { environment.symbolicHotKeysChecked ? environment.symbolicHotKeys : nil }) guard updated != systemShortcutKeys else { return } systemShortcutKeys = updated guard hotkeyBindings != nil, let configuration = services.engine?.configuration else { return } _ = refreshHotkeys(configuration, mode: services.engine?.snapshot.state.activeMode) } private func refreshHotkeys(_ configuration: ParcelConfiguration, mode: String?) -> [ConfigCommand: KeyChord] { guard let hotkeyBindings else { preconditionFailure("The hotkey registrar was not initialized") } do { try setupShortcuts?.clear() } catch { services.composition?.report(error, kind: .hotkeys) } let result = hotkeyBindings.reload(configuration, mode: mode) hotkeyMode = mode hotkeyGate.invalidate() registeredShortcutConfiguration = configuration registeredShortcutConfiguration?.keybindings = result.active let active = refreshShortcutPresentation() hotkeyInputFailure = result.conflicts.compactMap { inputFailure($0.cause) }.first let conflicts = result.conflicts.filter { inputFailure($0.cause) == nil } for conflict in result.conflicts { logger.error( "Shortcut \(conflict.chord.description, privacy: .public): \(String(describing: conflict.cause), privacy: .public)" ) } if conflicts.isEmpty { services.composition?.clearNotice(.hotkeys) } else { services.composition?.report(AppHotkeyFailure(chords: conflicts.map(\.chord)), kind: .hotkeys) } publishInputFailure() updateVoiceOverNotice() reloadSetupShortcuts() services.configureShortcutUpgradeHint(configuration, existingInstallation: !tourLaunchPolicy.isFirstRun) return active } private func refreshShortcutPresentation() -> [ConfigCommand: KeyChord] { guard let (installed, routes) = installedShortcutConfiguration() else { preconditionFailure("Shortcut presentation requires a registered configuration") } learningConfiguration = Self.shortcutPresentation( installed, secureInput: secureInput.isEnabled, routes: routes, isActive: acceptsHotkeyInput, voiceOverEnabled: VoiceOverStatus.isRunning) let active = learningConfiguration.keybindings if effectiveShortcuts != active { windowActionHintTask?.cancel() windowActionHints.stop() windowActionHintTarget = nil windowActionHintState = nil } effectiveShortcuts = active shell?.setEffectiveShortcuts(active) refreshLearning() return active } private func installedShortcutConfiguration() -> (ParcelConfiguration, [HotKey: HotKeyRoute])? { guard let configuration = registeredShortcutConfiguration, let hotkeys else { return nil } let routes = Dictionary(uniqueKeysWithValues: hotkeys.registrations.map { ($0.hotKey, $0.route) }) var installed = configuration installed.keybindings = configuration.keybindings.filter { DefaultKeybindings.isApplicationMenuShortcut(for: $0.key, chord: $0.value) || hotkeys.isAvailable(Self.hotkey($0.value)) } installed.defaultModeEntries = configuration.defaultModeEntries.filter { hotkeys.isAvailable(Self.hotkey($0.value)) } installed.modes = configuration.modes.mapValues { bindings in bindings.filter { action, chord in if case .command(let command) = action, DefaultKeybindings.isApplicationMenuShortcut(for: command, chord: chord) { return true } return hotkeys.isAvailable(Self.hotkey(chord)) } } return (installed, routes) } private func tourShortcutReferenceBindings() throws -> [ConfigCommand: KeyChord] { guard let engine = services.engine, engine.isRunning, hotkeyMode == engine.snapshot.state.activeMode, let (installed, routes) = installedShortcutConfiguration() else { throw TourSetupFailure.unavailable } return Self.shortcutPresentation( installed, secureInput: secureInput.isEnabled, routes: routes, isActive: true, voiceOverEnabled: VoiceOverStatus.isRunning ).keybindings } static func shortcutPresentation( _ configuration: ParcelConfiguration, secureInput: Bool, routes: [HotKey: HotKeyRoute] = [:], isActive: Bool = true, voiceOverEnabled: Bool = false ) -> ParcelConfiguration { func available(_ chord: KeyChord) -> Bool { let key = hotkey(chord) return configuration.general.shortcutsEnabled && isActive && !(voiceOverEnabled && key.conflictsWithVoiceOver) && (!secureInput || (routes[key] ?? HotKeyRoute.preferred(for: key)) == .carbon) } var presented = configuration presented.keybindings = configuration.keybindings.filter { available($0.value) } presented.defaultModeEntries = configuration.defaultModeEntries.filter { available($0.value) } presented.modes = configuration.modes.mapValues { $0.filter { available($0.value) } } return presented } private func secureInputChanged(_ enabled: Bool) { hotkeys?.resetEventTapPressedState() feedback?.controller.setSecureInput(enabled, ownerName: secureInput.ownerName) if enabled { hoverFocus.cancel() } if registeredShortcutConfiguration != nil { _ = refreshShortcutPresentation() } refreshMenuProblem() } private func prepareActivity(_ configuration: ParcelConfiguration) { settings.activity = activity activity.onFailure = { [weak self] error in self?.logger.error("Activity storage failed: \(error.localizedDescription)") self?.services.composition?.report( AppText.failure("Activity could not be read or saved. Review Settings → Activity.")) } activity.configure(enabled: configuration.general.collectActivity) } static func activityFileURL(configURL: URL, isolated: Bool) -> URL { if isolated, configURL == ConfigStore.defaultFileURL { return URL(fileURLWithPath: FileManager.default.currentDirectoryPath) .appendingPathComponent(".build/activity-tests/\(UUID())/activity.json") } if let path = ProcessInfo.processInfo.environment["PARCEL_ACTIVITY_PATH"] { return URL(fileURLWithPath: path) } return isolated ? configURL.deletingLastPathComponent().appendingPathComponent("activity.json") : URL.applicationSupportDirectory.appendingPathComponent("dev.vinnymac.parcel/activity.json") } static func setupFileURL(configURL: URL, isolated: Bool) -> URL { if let path = ProcessInfo.processInfo.environment["PARCEL_SETUPS_PATH"] { return URL(fileURLWithPath: path) } return isolated ? configURL.deletingLastPathComponent().appendingPathComponent("setups.json") : SetupStore.defaultFileURL } private func prepareSetups() async { settings.setups = setups setupApplications.onHidden = { [weak self] pids in self?.services.engine?.removeSetupHiddenApplications(pids) } setups.applicationName = { [weak self] bundle in self?.setupApplications.displayName(for: bundle) ?? AppText.string("Unavailable app") } setups.displayName = { [weak self] display in do { return try DisplayNaming.name(for: display, in: self?.services.engine?.snapshot.state ?? State()) } catch { self?.services.composition?.report(error) return AppText.string("Display unavailable") } } setups.runningBundleIDs = { [weak self] in guard let self else { throw CancellationError() } return self.setupApplications.runningBundleIDs } setups.onFailure = { [weak self] error in self?.services.composition?.report(AppFailure(message: error.localizedDescription)) } setups.onChange = { [weak self] in guard let self else { return } self.setupOverlay?.refresh() self.reloadSetupShortcuts() } if let engine = services.engine { setups.attach(to: engine) } guard !setupsPrepared else { return } do { try await setups.load() setupsPrepared = true } catch { logger.error("Setups could not load: \(error.localizedDescription)") } } private func reloadSetupShortcuts() { guard let setupShortcuts, let configuration = services.engine?.configuration ?? registeredShortcutConfiguration else { return } let reserved = Set( (Array(configuration.keybindings.values) + Array(configuration.defaultModeEntries.values) + configuration.modes.values.flatMap { $0.values }).map(Self.hotkey)) do { try setupShortcuts.reload( setups: hotkeyMode == nil ? setups.setups : [], shortcutsEnabled: configuration.general.shortcutsEnabled, reserved: reserved) } catch { services.composition?.report(AppFailure(message: error.localizedDescription)) } } static func workspaceStore(configURL: URL, fixtureOnly: Bool) -> WorkspaceStateStore { WorkspaceStateStore( fileURL: fixtureOnly ? configURL.deletingLastPathComponent().appendingPathComponent("workspace-state.json") : WorkspaceStateStore.defaultFileURL) } private func prepareWorkspaceMemorySettings() { guard settings.workspaceMemory == nil, let workspaceStateStore else { return } settings.workspaceMemory = AppWorkspaceMemory( store: workspaceStateStore, engine: { [weak self] in self?.services.engine }, didReset: { [weak self] in self?.services.composition?.clearNotice(.workspaceMemory) } ).settingsModel() } static func minimumStore(configURL: URL, fixtureOnly: Bool) -> MinimumSizeStore { MinimumSizeStore( fileURL: fixtureOnly ? configURL.deletingLastPathComponent().appendingPathComponent("minimum-sizes.json") : MinimumSizeStore.defaultFileURL) } func prepareFeedback() { guard feedback == nil else { return } let feedback = AppFeedback( sensory: feedbackSensory, onFailure: { [weak self] in self?.services.composition?.report($0, kind: .feedback) }) self.feedback = feedback settings.feedback = feedback.model feedback.controller.update( state: services.engine?.snapshot.state ?? State(), configuration: services.engine?.configuration.motion ?? learningConfiguration.motion, active: true) feedback.controller.setSecureInput(secureInput.isEnabled, ownerName: secureInput.ownerName) } private func postFixtureKey(_ request: AppFixtureKeyInput) async throws -> UInt64 { guard let engine = services.engine, engine.isRunning, settings.onRecordedShortcut == nil else { throw AppFixtureDrag.rejected("Fixture keyboard input needs active tiling without shortcut capture") } _ = synchronizeMode() guard let effectiveShortcuts else { throw AppFixtureDrag.rejected("Fixture shortcuts are not registered") } return try await request.post(state: engine.snapshot.state, activeBindings: effectiveShortcuts) } static func hotkey(_ chord: KeyChord) -> HotKey { var modifiers: HotKey.Modifiers = [] for (configured, native) in [ (KeyModifiers.ctrl, HotKey.Modifiers.control), (.alt, .option), (.cmd, .command), (.shift, .shift), (.fn, .function), ] { if chord.modifiers.contains(configured) { modifiers.insert(native) } } return HotKey(keyCode: chord.key.keyCode, modifiers: modifiers) } static func repeats(_ command: ConfigCommand) -> Bool { switch command { case .focusLeft, .focusRight, .focusUp, .focusDown, .ratioIncrease, .ratioDecrease: true default: false } } var isHoverFocusRunning: Bool { hoverFocus.isRunning } func synchronizeHoverFocus() throws { guard drag != nil else { return } try hoverFocus.synchronize() } func startDragMonitor() throws { do { try startDragMonitor(start: { try $0.start() }) } catch { let failure = inputFailure(error) ?? .installation mouseInputFailure = failure throw failure } } private func inputFailure(_ error: any Error) -> AppInputFailure? { AppInputFailure.classify( error, accessibility: permissions.status == .granted, inputMonitoring: Permissions.inputMonitoringIsGranted()) } private func publishInputFailure() { if let failure = [hotkeyInputFailure, mouseInputFailure].compactMap({ $0 }).first { services.composition?.report(failure, kind: .input) } else { services.composition?.clearNotice(.input) } } private func retryInputInstallation(_ status: PermissionStatus) { guard status == .granted, let engine = services.engine, engine.isRunning else { return } if hotkeyInputFailure != nil, hotkeyBindings != nil { _ = refreshHotkeys(engine.configuration, mode: engine.snapshot.state.activeMode) } if let mouseInputFailure, mouseInputFailure != .timeout { do { try startDragMonitor() } catch { services.composition?.report(error, kind: .input) } } } func startDragMonitor(start: @MainActor (DragMonitor) throws -> Void) throws { services.engine?.onMouseFeedback = { [weak self] feedback in self?.receive(feedback) } services.engine?.onMouseInputChanged = { [weak self] in self?.publishMouseInput() } let monitor = DragMonitor( onSample: { [weak self] sample, window in guard let self else { return } if sample.kind == .down { self.hoverFocus.cancel() self.learning?.performed(.mouse) if sample.wasClaimed == true { self.controls?.hover.hide(includingGrips: true) } } if sample.kind == .cancel || sample.kind == .interrupted { self.controls?.hover.cancelTabDrag() self.controls?.chips.cancelDrag() } self.services.engine?.handleMouse(sample, windowAtStart: window) self.publishMouseInput() }, onFailure: { [weak self] error in guard let self else { return } self.mouseInputFailure = self.inputFailure(error) ?? .installation self.publishInputFailure() }) monitor.publish(mouseInputSnapshot, ignoring: mousePassthroughWindows) try start(monitor) do { try hoverFocus.synchronize() } catch { monitor.stop() throw error } drag = monitor try dividerHandles.synchronize() mouseInputFailure = nil publishInputFailure() } private var mousePassthroughWindows: Set { Set(NSApplication.shared.windows.filter(\.ignoresMouseEvents).compactMap { UInt32(exactly: $0.windowNumber) }) } private var mouseInputSnapshot: MouseInputSnapshot { var snapshot = services.engine?.mouseInputSnapshot ?? MouseInputSnapshot() snapshot.consumesEscape = snapshot.consumesEscape || services.engine?.acceptsMouseInput == true && controls?.chips.isDragging == true return snapshot } private func publishMouseInput() { if services.engine?.acceptsMouseInput != true { controls?.hover.cancelTabDrag() controls?.chips.cancelDrag() } drag?.publish(mouseInputSnapshot, ignoring: mousePassthroughWindows) do { try dividerHandles.synchronize() } catch { services.composition?.report(error, kind: .input) } } func receive(_ feedback: EngineMouseFeedback) { switch feedback { case .layoutPreview(let preview): overlays?.layoutPreviewChanged(preview) case .targetChanged(let target): overlays?.legacyDragChanged( target: target.map { OverlayWindow(id: $0.window.rawValue, frame: $0.frame.cgRect) }) case .dropped(let velocity): self.feedback?.controller.dropped() overlays?.dropped(velocity: CGVector(dx: velocity.xCoordinate, dy: velocity.yCoordinate)) case .refused(let direction): overlays?.refused(direction) } } private func prepareLearning() async { prepareWorkspaceMemorySettings() await settings.start() do { try await AppHoverPreferences.migrate(defaults: defaults, settings: settings) } catch { services.composition?.report(error, kind: .configuration) } guard learning == nil else { return } if let error = tourLaunchPolicy.progressFailure ?? services.tourPersistenceFailure { services.composition?.report(error) } if let notice = tourLaunchPolicy.recoveryNotice { services.setTourRecoveryNotice(notice) } do { learning = try WindowLearningController( defaults: defaults, onFailure: { [weak self] in self?.services.composition?.report($0) }) } catch { services.composition?.report(error) } learning?.bindHoverPreferences(to: settings) learning?.setup.actions = AppTourIntegration.actions( settings: settings, services: services, permissions: permissions, defaults: defaults, targetDisplay: { [weak self] in self?.learning?.setupDisplay }, openShortcuts: { [weak self] in guard let shell = self?.shell else { throw TourSetupFailure.unavailable } shell.showKeyboardShortcuts() }, openConfigurationSettings: { [weak self] in guard let shell = self?.shell else { throw TourSetupFailure.unavailable } shell.showSettings() }, acceptCurrentPlacement: { [weak self] in guard let self else { throw CancellationError() } guard self.services.engine?.isRunning == true else { return } guard let world = self.world else { throw TourSetupFailure.unavailable } try world.acceptCurrentPlacement() }, effectiveBindings: { [weak self] in guard let self else { throw TourSetupFailure.unavailable } return try self.tourShortcutReferenceBindings() }, loginStatus: { [weak self] in guard let self else { throw TourSetupFailure.unavailable } return try self.tourLoginStatus() }) learning?.onTourPresented = { [weak self] in self?.services.holdForTour() } learning?.onTourResolved = { [weak self] in self?.refreshInputActivity() } learning?.onHoverPreferencesChanged = { [weak self] in self?.saveHoverPreferences($0) } } private func prepareControls() throws { guard controls == nil else { return } let controls = try WindowControlsController( defaults: defaults, settingsModel: settings, focus: { [weak self] in self?.focusStackWindow($0) }, close: { [weak self] in self?.closeStackWindow($0) }, cycle: { [weak self] in self?.cycleStackWindow($0, direction: $1) }, move: { [weak self] in self?.moveStackWindow($0, target: $1) }, hoverAction: { [weak self] request in guard let self else { throw AppText.failure("Parcel is shutting down.") } try await self.performHoverAction(request) }, hoverFocusToggle: { [weak self] in guard let self else { return } self.dispatch { try await self.services.send(.toggleHoverFocus) } }, onInput: { [weak self] in self?.learning?.performed($0) }, onFailure: { [weak self] in self?.services.composition?.report($0) }) controls.onStackedWindows = { [weak self] in guard let self else { return } do { try self.openTabView(nil) } catch { self.services.composition?.report(error) } } controls.onChromeChanged = { [weak self] in guard let self else { return } self.drag?.publish(self.mouseInputSnapshot, ignoring: self.mousePassthroughWindows) } controls.chips.onDragStateChanged = { [weak self, weak controls] active in if !active { controls?.hover.cancelTabDrag() } self?.publishMouseInput() } controls.onHoverPreferencesChanged = { [weak self] in self?.saveHoverPreferences($0) } try controls.start() self.controls = controls } private func saveHoverPreferences(_ preferences: HoverBarConfiguration) { dispatch { [weak self] in guard let self else { return } guard let composition = self.services.composition else { throw AppText.failure("Parcel is shutting down.") } try await self.settings.setHoverPreferences(preferences) let snapshot = await composition.reload() if snapshot.loadState == .rejected || (composition.phase == .running && composition.configuration != snapshot.activeConfiguration) { throw AppText.failure( "Hover bar settings could not be applied. Review the configuration in Settings.") } } } private func refreshLearning() { guard let engine = services.engine else { return } if let target = windowActionHintTarget, let state = windowActionHintState, !WindowActionHint.remainsCurrent(after: state, current: engine.snapshot.state, window: target) { windowActionHints.stop() windowActionHintTarget = nil windowActionHintState = nil } learning?.update( state: engine.presentationState, configuration: learningConfiguration, active: engine.isRunning && engine.isAutomaticTilingEnabled) controls?.update( state: engine.presentationState, configuration: learningConfiguration, active: engine.isRunning && engine.systemWindowConflict == nil && !services.isTourUnresolved) } deinit { snapshotTask?.cancel() for task in commandTasks.values { task.cancel() } } } extension NativeAppRuntime { func startShell() async throws { applyAppearance(services.composition?.configuration.appearance ?? learningConfiguration.appearance) prepareFeedback() prepareActivity(services.composition?.configuration ?? learningConfiguration) await prepareSetups() setupMenu = SetupMenuController( coordinator: setups, shortcutIsActive: { [weak self] setup in self?.setupShortcuts?.actions.values.contains(setup.id) == true }) setupOverlay = SetupLoadingOverlay( coordinator: setups, motionConfiguration: { [weak self] in self?.services.engine?.configuration.motion ?? MotionConfiguration() }) secureInput.start() shortcutEnvironment.start() await prepareLearning() try prepareControls() let shell = ParcelShell( layouts: services, permissions: permissions, commands: services, configStore: store, defaults: defaults, settingsModel: settings) shell.usesNativeAutosave = !usesIsolatedState self.shell = shell shell.onFailure = { [weak self] in self?.services.composition?.report($0) } shell.onSupportDiagnostics = { [weak self] in guard let self else { throw CancellationError() } let handler = AppIPCHandler( services: self.services, configPath: self.store.fileURL.path, permission: { [permissions = self.permissions] in permissions.status == .granted }) return SupportRuntimeDiagnostics(snapshot: try await handler.diagnostics()) } shortcutEnvironment.onApplicationChanged = { [weak self] in self?.settings.refreshShortcutWarnings() } shell.onInspectorRequested = { [weak self] in self?.showFloatingInspector() } shell.onActiveModeChanged = { [weak self] in self?.feedback?.controller.setActiveMode($0) } shell.setActiveMode(services.engine?.snapshot.state.activeMode) shell.setEffectiveShortcuts(effectiveShortcuts) shell.onTourRequested = { [weak self] afterOnboarding in guard let self, let learning = self.learning else { return } self.requestTour(afterOnboarding: afterOnboarding, alreadyPresented: learning.setup.isPresented) { showWelcome, defaultOpenAtLogin in learning.present(afterOnboarding: showWelcome, defaultOpenAtLogin: defaultOpenAtLogin) } } shell.onProblemRequested = { [weak self] problem in self?.resolveMenuProblem(problem) } shell.onInstallUpdate = { [weak self] in self?.resolveMenuProblem(.updateReady) } shell.onDeferUpdate = { [weak self] in guard let self, self.updater.isReadyToRestart else { return } self.updateDeferred = true self.deferredUpdateVersion = self.updater.availableVersion self.refreshMenuProblem() } shell.onTransientNotice = { [weak self] message in guard let self else { return } self.prepareFeedback() self.feedback?.controller.showTransientNotice(message) } services.onTransientNotice = { [weak self] message, accessibilityMessage in guard let self else { return } self.prepareFeedback() self.feedback?.controller.showTransientNotice(message, accessibilityMessage: accessibilityMessage) } services.configureShortcutUpgradeHint( services.engine?.configuration ?? services.composition?.configuration ?? learningConfiguration, existingInstallation: !tourLaunchPolicy.isFirstRun) shell.onApplicationMenuRendered = { [weak self] menu in self?.feedback?.controller.installMenuItems(in: menu, at: max(0, menu.numberOfItems - 1)) self?.controls?.installMenuItem(in: menu, at: menu.numberOfItems - 1) } shell.onMenuRendered = { [weak self] menu in guard let more = menu.items.first(where: { $0.identifier?.rawValue == "menu.more" })?.submenu else { preconditionFailure("The status menu needs a More submenu") } self?.updater.installMenuItem(in: more, at: 1) self?.setupMenu?.install(in: menu) } try await shell.start() shell.menuBar?.activeScreenForPresentation = { [weak self] in guard let self, let display = self.services.engine?.snapshot.state.activeDisplay else { return nil } do { return try NSScreen.screens.first { try DisplayNaming.id(for: $0) == display } } catch { self.logger.error("Menu presentation display could not be identified: \(error.localizedDescription)") return nil } } shell.menuBar?.applicationForMenu = { [weak self] in guard let self else { return nil } let frontmost = NSWorkspace.shared.frontmostApplication let application = frontmost?.processIdentifier == getpid() ? self.shortcutEnvironment.applicationPID.flatMap(NSRunningApplication.init(processIdentifier:)) : frontmost return self.ruleControls.menuApplication(application) } shell.menuBar?.toggleApplication = { [weak self] application in self?.ruleControls.toggleApplication(application) } shell.menuBar?.onMenuNeedsUpdate = { [weak self] in guard let self else { return } self.updateDeferred = false self.deferredUpdateVersion = nil _ = self.secureInput.refresh() self.refreshMenuProblem() } shell.menuBar?.workspaceForActivation = { [weak self] activation in self?.menuWorkspace(activation) ?? .failure(.disconnected) } shell.menuBar?.invokeInWorkspace = { [weak self] command, workspace in self?.dispatch { [weak self] in guard let self else { throw CancellationError() } try await self.services.send(command, in: workspace.key) } } shell.showSuspensionStatus(services.engine.flatMap { Self.suspensionStatus($0.snapshot) }) refreshMenuProblem() } private func performFixtureMenuAction(_ arguments: [String]) async throws { guard fixtureOnly, ProcessInfo.processInfo.environment["PARCEL_E2E"] == "1" else { throw AppFixtureMenuFailure(stage: .eligibility) } let count = try AppFixtureMenuFailure.windowCount(arguments) guard let engine = services.engine, engine.isRunning, let menuBar = shell?.menuBar, let button = menuBar.statusItem.button, let window = button.window, let statusScreen = window.screen else { throw AppFixtureMenuFailure(stage: .runtime) } guard CGPreflightPostEventAccess(), let cursor = CGEvent(source: nil) else { throw AppFixtureMenuFailure(stage: .permission) } guard !CGEventSource.buttonState(.combinedSessionState, button: .left), !CGEventSource.buttonState(.combinedSessionState, button: .right), CGEventSource.flagsState(.combinedSessionState) .intersection([.maskCommand, .maskAlternate, .maskControl, .maskShift, .maskSecondaryFn]).isEmpty else { throw AppFixtureMenuFailure(stage: .heldInput) } let display = DisplayID(rawValue: arguments[0]) guard try DisplayNaming.id(for: statusScreen) == display else { throw AppFixtureMenuFailure(stage: .display) } guard let space = engine.snapshot.state.activeSpaces[display], let workspace = engine.snapshot.state.workspaces[WorkspaceKey(display: display, space: space)], !workspace.order.isEmpty else { throw AppFixtureMenuFailure(stage: .workspace) } let frame = window.convertToScreen(button.convert(button.bounds, to: nil)) let point = CGPoint(x: frame.midX, y: frame.midY) let location = CGPoint(x: point.x, y: CGDisplayBounds(CGMainDisplayID()).height - point.y) guard statusScreen.frame.contains(point), let source = CGEventSource(stateID: .privateState), let down = CGEvent( mouseEventSource: source, mouseType: .leftMouseDown, mouseCursorPosition: location, mouseButton: .left), let up = CGEvent( mouseEventSource: source, mouseType: .leftMouseUp, mouseCursorPosition: location, mouseButton: .left) else { throw AppFixtureMenuFailure(stage: .eventCreation) } func captureMouse(_ phase: String) throws { guard ProcessInfo.processInfo.environment["PARCEL_E2E_ARTIFACTS"] != nil, let log = ProcessInfo.processInfo.environment["PARCEL_E2E_LOG_PATH"] else { return } let mouse = engine.fixtureMouseState let value = JSONValue.object([ "dragging": .array(mouse.dragging.map { .integer(Int64($0)) }), "pointer_down": .bool(mouse.pointerDown), "uses_samples": .bool(mouse.usesSamples), "active": mouse.active.map { .integer(Int64($0)) } ?? .null, ]) try JSONEncoder().encode(value).write( to: URL(fileURLWithPath: log).deletingLastPathComponent() .appendingPathComponent("menu-mouse-\(phase).json"), options: .atomic) } try captureMouse("before-click") let rendered = menuBar.onMenuRendered var result: Result? var menuWasBuilt = false menuBar.onMenuRendered = { menu in menuWasBuilt = true rendered?(menu) let identifier = NSUserInterfaceItemIdentifier(ConfigCommand.setWindowCap(count).rawValue) let item = menu.items.compactMap(\.submenu).flatMap(\.items).first { $0.identifier == identifier } DispatchQueue.main.async { do { try captureMouse("before-action") } catch { menu.cancelTrackingWithoutAnimation() result = .failure(error) return } if ProcessInfo.processInfo.environment["PARCEL_E2E_CAPTURE_MENU"] == "1" { do { guard let log = ProcessInfo.processInfo.environment["PARCEL_E2E_LOG_PATH"], let window = menu.items.first?.view?.window, window.isVisible, let content = window.contentView, let bitmap = content.bitmapImageRepForCachingDisplay(in: content.bounds) else { throw AppFixtureMenuFailure(stage: .capture) } content.cacheDisplay(in: content.bounds, to: bitmap) guard let png = bitmap.representation(using: .png, properties: [:]) else { throw AppFixtureMenuFailure(stage: .capture) } try png.write( to: URL(fileURLWithPath: log).deletingLastPathComponent() .appendingPathComponent("menu.png"), options: .atomic) } catch { menu.cancelTrackingWithoutAnimation() result = .failure(error) return } } menuBar.dismiss() guard let item, item.isEnabled, let submenu = item.menu else { result = .failure(AppFixtureMenuFailure(stage: .selection)) return } submenu.performActionForItem(at: submenu.index(of: item)) result = .success(()) } } defer { menuBar.onMenuRendered = rendered } do { guard CGWarpMouseCursorPosition(location) == .success else { throw AppFixtureMenuFailure(stage: .cursorMovement) } for event in [down, up] { event.flags = [] event.setIntegerValueField(.mouseEventClickState, value: 1) event.post(tap: .cghidEventTap) try await Task.sleep(for: .milliseconds(50)) } let deadline = ContinuousClock.now.advanced(by: .seconds(5)) while result == nil { guard ContinuousClock.now < deadline else { throw AppFixtureMenuFailure(stage: menuWasBuilt ? .selectionDispatch : .presentation) } try await Task.sleep(for: .milliseconds(50)) } if let result { try result.get() } } catch { menuBar.menu.cancelTrackingWithoutAnimation() up.post(tap: .cghidEventTap) guard CGWarpMouseCursorPosition(cursor.location) == .success else { logger.error( "Fixture menu failed before pointer restoration: \(error.localizedDescription, privacy: .public)") throw AppFixtureMenuFailure(stage: .cursorRestoration) } throw error } guard CGWarpMouseCursorPosition(cursor.location) == .success else { throw AppFixtureMenuFailure(stage: .cursorRestoration) } try captureMouse("after-action") } static func suspensionStatus(_ snapshot: EngineSnapshot) -> String? { let display = snapshot.state.activeWorkspace?.display ?? snapshot.state.activeDisplay return snapshot.displaySuspensions.first { display == nil || $0.display == display } .map { AppMenuSuspension.text($0.reason) } } func menuWorkspace( _ activation: MenuWorkspaceActivation ) -> Result { guard let engine = services.engine, engine.isRunning else { return .failure(.notRunning) } do { let displays = try DisplayNaming.screens() let screens = Dictionary(uniqueKeysWithValues: displays.map { ($0.id, $0.frame) }) let state = engine.snapshot.state let statusDisplay = try activation.statusScreen.map { try DisplayNaming.id(for: $0) } let target = MenuWorkspace.target( at: activation.pointer, statusDisplay: statusDisplay, screens: screens, state: state) return target.flatMap { key in guard let snapshot = services.menuSnapshot(engine.snapshot, in: key) else { return .failure(.unmanagedSpace) } let desktop = Self.menuDesktop(in: key, displays: desktopSpaces) if let desktop, desktop.kind != .desktop { return .failure(.unmanagedSpace) } return .success( MenuWorkspace( key: key, snapshot: snapshot, displayName: DisplayNaming.name(for: key.display, screens: displays, state: state), desktopNumber: desktop?.desktopNumber, hasFocusedWindow: state.focusedWindow.flatMap { state.workspace(containing: $0) } == key, hasMultipleDisplays: state.displays.count > 1, disabledReasons: services.menuDisabledReasons(engine.snapshot, in: key))) } } catch { services.composition?.report(error) return .failure(.disconnected) } } static func menuDesktop(in key: WorkspaceKey, displays: [NativeDisplaySpaces]) -> NativeSpace? { let display = displays.first { $0.displayID.caseInsensitiveCompare(key.display.rawValue) == .orderedSame } ?? displays.first { $0.displayID == "Main" } return display?.spaces.first { $0.id == key.space.rawValue } } private func auditSettings() async throws -> JSONValue { let thread = try AppThread(pid: getpid()) defer { thread.shutdown() } guard let engine = services.engine else { throw AppText.failure("Parcel is not tiling right now.") } let adapter = floatingInspectorAdapter(engine) let enhanced = try await thread.perform { try $0.enhancedUI } try await thread.perform { try $0.setEnhancedUI(true) } do { var controls = try await SettingsAccessibilityAudit.run( model: settings, permissions: AnyView( PermissionsView(model: shell?.onboarding ?? OnboardingModel(provider: permissions)))) controls += try await SettingsAccessibilityAudit.runInspector( model: FloatingWindowInspectorModel(inspect: adapter.inspect, tile: adapter.tile), settings: settings) try await thread.perform { try $0.setEnhancedUI(enhanced) } return try JSONDecoder().decode(JSONValue.self, from: JSONEncoder().encode(controls)) } catch { let failure = error do { try await thread.perform { try $0.setEnhancedUI(enhanced) } } catch { services.composition?.report(error) } throw failure } } private func floatingInspectorAdapter(_ engine: ParcelEngine) -> AppFloatingInspector { let frontmost = NSWorkspace.shared.frontmostApplication?.processIdentifier let pid = frontmost == getpid() ? shortcutEnvironment.applicationPID : frontmost let focused = engine.snapshot.focusedWindow.flatMap { id in pid == nil || engine.snapshot.state.windows[id]?.app.pid == pid ? id : nil } return AppFloatingInspector( engine: engine, focusedWindow: focused, inspectionWorld: world, focusedPID: pid, isTourResolved: { [services] in !services.isTourUnresolved }) } private func showFloatingInspector() { guard let engine = services.engine else { services.composition?.report(AppText.failure("Accessibility access is required before tiling can start.")) return } let adapter = floatingInspectorAdapter(engine) inspector?.close() inspector = FloatingWindowInspectorController( model: FloatingWindowInspectorModel(inspect: adapter.inspect, tile: adapter.tile), settings: settings) inspector?.show() } private func openWindowSettings() { guard let url = URL(string: "x-apple.systempreferences:com.apple.Desktop-Settings.extension"), NSWorkspace.shared.open(url) else { services.composition?.report(SystemSettingsFailure.unavailable) return } } func showOnboarding() { shell?.showOnboarding() } func reopen() { shell?.reopen() } func showSettings() { shell?.showSettings() } func showNotice(_ notice: String?) { showNotice(notice, actions: []) } func showNotice(_ notice: String?, actions: [NoticeAction]) { if let notice { feedback?.controller.showTransientNotice(notice) } refreshMenuProblem() } func showNotice(_ report: AppNotices.Report) { prepareFeedback() feedback?.controller.showTransientNotice(report.message, kind: report.kind.rawValue, count: report.count) refreshMenuProblem() } func clearNotice(_ kind: AppNotices.Kind) { feedback?.controller.clearTransientNotice(kind: kind.rawValue) refreshMenuProblem() } private func openNoticeAction(_ action: NoticeAction) { let opened: Bool switch action { case .accessibilitySettings: opened = Permissions.openSettings(.accessibility) case .inputMonitoringSettings: opened = Permissions.openSettings(.inputMonitoring) case .shortcutSettings, .layoutSettings: showSettings() return case .useAlternatePrefix: dispatch { [weak self] in guard let self else { throw CancellationError() } try await AppTourIntegration.useAlternatePrefix(settings: self.settings, services: self.services) } return case .retryStartup: dispatch { [weak self] in await self?.services.composition?.retryStartup() } return } if !opened { services.composition?.report( AppFailure( message: AppText.notice( "System Settings could not be opened. Open Privacy & Security in System Settings and review Parcel’s access." ))) } } func showProblem(_ problem: MenuProblem?) { compositionProblem = problem refreshMenuProblem() } private func refreshMenuProblem() { let ready = updater.isReadyToRestart let version = updater.availableVersion if !ready || (updateDeferred && deferredUpdateVersion != version) { updateDeferred = false deferredUpdateVersion = nil } shell?.showUpdate(ready: ready, version: version, showCard: !updateDeferred) let configured = services.composition?.configuration.keybindings ?? learningConfiguration.keybindings let shortcutsOff = if let hotkeys { acceptsHotkeyInput && !configured.isEmpty && hotkeys.registrations.allSatisfy { !hotkeys.isAvailable($0.hotKey) } } else { false } shell?.showProblem( Self.menuProblem( shortcutsOff: shortcutsOff, secureInput: secureInput.isEnabled, secureInputOwner: secureInput.ownerName, updateReady: updater.isReadyToRestart, configuration: compositionProblem, noticeActions: services.composition?.notices.shortcutRepairActions ?? [])) } static func menuProblem( shortcutsOff: Bool, secureInput: Bool, secureInputOwner: String?, updateReady: Bool, configuration: MenuProblem?, noticeActions: [NoticeAction] = [] ) -> MenuProblem? { if noticeActions.contains(.retryStartup) { return .startupFailure } if noticeActions.contains(.useAlternatePrefix) { return .voiceOverShortcutConflict } if shortcutsOff { return .shortcutsOff } if case .configuration = configuration { return configuration } if secureInput { return .secureInput(ownerName: secureInputOwner) } if updateReady { return .updateReady } return nil } static func shortcutRepairAction(_ actions: [NoticeAction]) -> NoticeAction { if actions.contains(.retryStartup) { return .retryStartup } if actions.contains(.useAlternatePrefix) { return .useAlternatePrefix } return actions.first { $0 == .inputMonitoringSettings || $0 == .accessibilitySettings } ?? .accessibilitySettings } private func resolveMenuProblem(_ problem: MenuProblem) { switch problem { case .shortcutsOff: openNoticeAction(Self.shortcutRepairAction(services.composition?.notices.shortcutRepairActions ?? [])) case .voiceOverShortcutConflict: openNoticeAction(.useAlternatePrefix) case .startupFailure: openNoticeAction(.retryStartup) case .secureInput: break case .updateReady: guard updater.restartToUpdate() else { services.composition?.report(AppText.failure("The update is no longer ready to restart.")) refreshMenuProblem() return } case .configuration(let reason): do { try configViewer.show( fileURL: store.fileURL, line: services.composition?.diagnostics.first(where: { $0.severity == .error })?.location.line, reason: reason ) } catch { services.composition?.report(error) } } } var usesIsolatedState: Bool { fixtureOnly || isolatedStorage } func tourLoginStatus() throws -> TourLoginStatus { if usesIsolatedState || AppTourIntegration.isRealDesktopAudit() { return fixtureOpenAtLogin ? .enabled : .disabled } return try AppTourIntegration.systemLoginStatus() } func setLaunchAtLogin(_ enabled: Bool) throws { if usesIsolatedState || AppTourIntegration.isRealDesktopAudit() { fixtureOpenAtLogin = enabled return } let item = SMAppService.mainApp if Self.shouldRegisterLoginItem(enabled: enabled, status: item.status) { try item.register() } if !enabled, item.status == .enabled || item.status == .requiresApproval { try item.unregister() } } static func shouldRegisterLoginItem(enabled: Bool, status: SMAppService.Status) -> Bool { enabled && status != .enabled && status != .requiresApproval } func flushActivityOnQuit() { activity.flushOnQuit() } func stopInput() throws { setups.cancelOpening() setupOverlay?.stop() try setupShortcuts?.clear() setupShortcuts = nil dividerHandles.stop() drag?.stop() drag = nil hoverFocus.stop() overlays?.dragChanged(target: nil) learning?.pause() controls?.stop() controls = nil for task in commandTasks.values { task.cancel() } commandTasks.removeAll() tabView?.cancel(immediately: true) tabView = nil tabViewMinimized = [:] try hotkeys?.stop() hotkeys = nil hotkeyBindings?.clear() hotkeyBindings = nil hotkeyMode = nil effectiveShortcuts = nil registeredShortcutConfiguration = nil hotkeyInputFailure = nil mouseInputFailure = nil shell?.setEffectiveShortcuts(nil) hotkeyGate.invalidate() shell?.setActiveMode(nil) } func restoreAndStopEngine() async throws { setups.cancelOpening() if let restorationTask { try await restorationTask.value return } guard let engine = services.engine, engine.isRunning, let world else { return } tabView?.cancel(immediately: true) tabViewMinimized = [:] let task = Task { @MainActor in defer { self.services.engine = nil self.world = nil self.nativeWorld = nil self.shell?.setActiveMode(nil) } self.snapshotTask?.cancel() await self.snapshotTask?.value self.snapshotTask = nil self.settings.updateRunningLayouts([:], activeDisplay: nil) self.overlays?.stop() self.overlays = nil self.feedback?.controller.update( state: engine.snapshot.state, configuration: engine.configuration.motion, active: false) if engine.configuration.memory.enabled { do { try await engine.saveWorkspaceMemory() } catch { self.services.composition?.report(error, kind: .workspaceMemory) } } world.beginRestoration() await engine.stop() await self.callbackRunner.stop() try await world.restoreAndStop() self.logger.info("Engine stopped and window restoration completed.") } restorationTask = task defer { restorationTask = nil } try await task.value } func stopIPC() async throws { try await server?.stop() server = nil } func stopShell() async { activity.flushOnQuit() setups.cancelOpening() setupOverlay?.stop() setupOverlay = nil setupMenu?.stop() setupMenu = nil secureInput.stop() voiceOverObservation?.cancel() voiceOverObservation = nil feedback?.controller.stop() windowActionHintTask?.cancel() windowActionHints.stop() settings.feedback = nil feedback = nil permissions.stop() shortcutEnvironment.stop() inspector?.close() inspector = nil configViewer.close() ruleControls.stop() await shell?.stop() await settings.stop() shell = nil learning?.stop() learning = nil controls?.stop() controls = nil } static func tabViewUnavailable(permission: PermissionStatus) -> AppFailure { switch permission { case .missing: AppText.failure("Turn on Accessibility for Parcel to use Tab View.") case .checking: AppText.failure("Parcel is checking Accessibility access. Try Tab View again in a moment.") case .granted: AppText.failure("Parcel is not running. Try Tab View again after Parcel starts.") } } private func requireTabViewEngine() throws -> ParcelEngine { guard permissions.status != .missing, let engine = services.engine, engine.isRunning else { throw Self.tabViewUnavailable(permission: permissions.status) } return engine } func openTabView(_ press: HotKeyPress?) throws { try services.requireTourResolved() let engine = try requireTabViewEngine() guard let tabView else { throw AppText.failure("Tab View is unavailable. Try again after shortcuts start.") } let cached = nativeWorld?.minimizedWindows ?? [] tabViewMinimized = Dictionary(uniqueKeysWithValues: cached.map { ($0.window.id, $0) }) try tabView.open( press: press, state: engine.snapshot.state, minimized: cached.map { AppTabViewMinimized(window: $0.window, frame: $0.frame, lastKnownWorkspace: $0.lastKnownWorkspace) }, configuration: engine.configuration.motion, classifier: engine.tabViewClassifier) } private func chooseTabViewWindow(_ window: WindowID, minimized: Bool) { let cached = tabViewMinimized[window] tabViewMinimized = [:] dispatch { [weak self] in guard let self else { throw CancellationError() } try await self.selectTabViewWindow(window, minimized: minimized, cached: cached) } } func selectTabViewWindow(_ window: WindowID, minimized: Bool, cached: MinimizedWindow?) async throws { let engine = try requireTabViewEngine() guard let world else { throw EngineError.stopped } if minimized { guard let cached, let nativeWorld else { throw EnginePlatformFailure.vanished(window) } try await nativeWorld.restore(window: cached) guard services.engine === engine else { throw EngineError.stopped } _ = try requireTabViewEngine() } else { guard let key = engine.snapshot.state.workspace(containing: window), engine.snapshot.state.isActive(key) else { throw EnginePlatformFailure.vanished(window) } } AppTabViewFocus.request( window, world: world, isCurrent: { [weak self, weak engine] in guard let self, let engine else { return false } return self.services.engine === engine && engine.isRunning && self.permissions.status != .missing }, onFocused: { [weak engine] in guard let engine, let key = engine.snapshot.state.workspace(containing: window), engine.snapshot.state.isActive(key) else { return } engine.send(.focusChanged(window)) }, onFailure: { [weak self] failure in self?.services.composition?.report(failure) }) } private func dispatch(_ action: @escaping @MainActor () async throws -> Void) { let id = UUID() commandTasks[id] = Task { @MainActor [weak self] in defer { self?.commandTasks.removeValue(forKey: id) } do { try await action() } catch is CancellationError {} catch { self?.services.composition?.report(error) } } } } private enum SystemSettingsFailure: Error { case unavailable } extension NativeAppRuntime { func closeStackWindow(_ window: WindowID) { guard !services.isTourUnresolved, let engine = services.engine, engine.isRunning, let nativeWorld, let key = engine.snapshot.state.workspace(containing: window), engine.snapshot.state.isActive(key), engine.snapshot.state.workspaces[key]?.tree?.stacks.contains(where: { $0.windows.count > 1 && $0.windows.contains(window) }) == true, closingWindows.insert(window).inserted else { return } let title = engine.snapshot.state.windows[window]?.title ?? "" dispatch { [weak self, weak engine] in defer { self?.closingWindows.remove(window) } try await nativeWorld.close(window) { edited in guard let engine, self?.services.isTourUnresolved == false, self?.services.engine === engine, engine.isRunning else { return false } guard StackCloseConfirmation.confirm(title: title, edited: edited), self?.services.isTourUnresolved == false, self?.services.engine === engine, engine.isRunning, let key = engine.snapshot.state.workspace(containing: window), engine.snapshot.state.isActive(key), engine.snapshot.state.workspaces[key]?.tree?.stacks.contains(where: { $0.windows.count > 1 && $0.windows.contains(window) }) == true else { return false } return true } } } func focusStackWindow(_ window: WindowID) { guard !services.isTourUnresolved, let engine = services.engine, engine.isRunning, let world, let key = engine.snapshot.state.workspace(containing: window), engine.snapshot.state.isActive(key), engine.snapshot.state.workspaces[key]?.tree?.stacks.contains(where: { $0.windows.count > 1 && $0.windows.contains(window) }) == true else { return } world.focus(window) { [weak self, weak engine] failure in if let failure { self?.services.composition?.report(failure) return } guard let engine, self?.services.isTourUnresolved == false, self?.services.engine === engine, engine.isRunning, let key = engine.snapshot.state.workspace(containing: window), engine.snapshot.state.isActive(key) else { return } engine.send(.focusChanged(window)) } } } extension NativeAppRuntime { private func setHoverFocusEnabled() async throws { guard let engine = services.engine, engine.isRunning else { throw AppText.failure("Hover focus controls are unavailable. Start tiling and try again.") } let enabled = !engine.snapshot.state.hoverFocusEnabled try await settings.setValue(.bool(enabled), for: .mouse(.focusFollowsMouse)) try await reloadMouseConfiguration() engine.send(.hoverFocusConfigured(enabled)) hoverFocus.cancel() } private func reloadMouseConfiguration() async throws { guard let composition = services.composition else { throw AppText.failure("Parcel is shutting down.") } let snapshot = await composition.reload() guard snapshot.loadState != .rejected, composition.phase != .running || composition.configuration == snapshot.activeConfiguration else { throw AppText.failure("Mouse controls could not be applied. Review the configuration in Settings.") } } func performHoverAction(_ request: HoverActionRequest) async throws { guard !services.isTourUnresolved, let engine = services.engine, engine.isRunning, engine.systemWindowConflict == nil, engine.snapshot.state.workspace(containing: request.window) == request.workspace, engine.snapshot.state.isActive(request.workspace), engine.snapshot.state.windows[request.window] != nil else { throw AppText.failure("This window is no longer available for mouse controls.") } let before = engine.snapshot.state switch request.action { case .makePrimary, .toggleFocus, .toggleFloat: let command: Command switch request.action { case .makePrimary: command = .makePrimary case .toggleFocus: command = .toggleFocus default: command = .toggleFloat } let result = try await engine.perform( command, targeting: request.window, workspace: request.workspace, activitySource: .mouse) guard result.isAccepted else { throw AppText.failure("The mouse action could not finish. Review the window and try again.") } case .moveToDisplay(let display): guard engine.isAutomaticTilingEnabled else { throw AppText.failure("Automatic tiling is off. Turn it on before moving windows with mouse controls.") } guard engine.moveWindow(request.window, to: display) else { throw AppText.failure("The mouse action could not finish. Review the window and try again.") } case .alwaysFloat: let result = try await engine.alwaysFloat(window: request.window) guard result.isAccepted else { throw AppText.failure("The mouse action could not finish. Review the window and try again.") } } let after = engine.snapshot.state windowActionHintTask?.cancel() windowActionHints.stop() windowActionHintTarget = nil windowActionHintState = nil guard WindowActionHint.make( request: request, before: before, after: after, configuration: engine.configuration) != nil else { return } windowActionHintTask = Task { @MainActor [weak self, weak engine] in guard let self, let engine else { return } do { try await engine.awaitWorkspaceSettled(in: request.workspace, timeout: .seconds(2)) } catch { // Placement failures already use the engine's actionable feedback channel. return } guard !Task.isCancelled, self.services.engine === engine, WindowActionHint.remainsCurrent(after: after, current: engine.snapshot.state, window: request.window) else { return } var configuration = engine.configuration configuration.keybindings = self.effectiveShortcuts ?? [:] guard let hint = WindowActionHint.make( request: request, before: before, after: engine.snapshot.state, configuration: configuration) else { return } self.windowActionHintTarget = request.window self.windowActionHintState = after self.windowActionHints.show( hint, display: after.displays[request.workspace.display]?.frame, motion: configuration.motion) self.drag?.publish(self.mouseInputSnapshot, ignoring: self.mousePassthroughWindows) } } private func cycleStackWindow(_ window: WindowID, direction: CycleDirection) { guard !services.isTourUnresolved, let engine = services.engine, engine.isRunning, let key = engine.snapshot.state.workspace(containing: window), engine.snapshot.state.isActive(key) else { return } engine.send( .commandForWindow( window, direction == .next ? .focusNextInStack : .focusPreviousInStack, workspace: key), activitySource: .mouse) } private func moveStackWindow(_ window: WindowID, target: WindowID) { if services.engine?.isAutomaticTilingEnabled == false, !services.isTourUnresolved { services.composition?.report( AppText.failure("Automatic tiling is off. Turn it on before moving windows with mouse controls.")) return } guard !services.isTourUnresolved, let engine = services.engine, engine.dropWindow(window, onto: target) else { services.composition?.report( AppText.failure("The mouse action could not finish. Review the window and try again.")) return } feedback?.controller.dropped() } } @MainActor final class AppEngineLog: EngineLogSink { var failure: @MainActor (any Error, AppNotices.Kind) -> Void = { _, _ in } var refusal: @MainActor (Direction) -> Void = { _ in } private let log: SystemEngineLog convenience init() { let logger = Logger(subsystem: "dev.vinnymac.parcel", category: "engine") self.init( log: SystemEngineLog(clock: SystemEngineClock(), scheduler: RunLoopEngineScheduler()) { message in logger.info("\(message, privacy: .public)") }) } init(log: SystemEngineLog) { self.log = log } func flush() { log.flush() } func forgetFailures(for app: AppID) { log.forgetFailures(for: app) } func record(_ diagnostic: EngineDiagnostic) { log.record(diagnostic) if let kind = AppNotices.kind(for: diagnostic) { switch diagnostic { case .internalFailure(let error): failure(error, kind) case .platform(.unexpected(let error)): failure(error.cause, kind) default: failure(AppFailure(message: kind.message), kind) } } if case .core(.noNeighbor(let direction)) = diagnostic { refusal(direction) } } } @MainActor final class AppAnnouncer: EngineAnnouncer { private let onModeChange: @MainActor () -> Void private let postAnnouncement: @MainActor (String) -> Void private let allowsLayoutNotice: @MainActor (Announcement) -> Bool init( postAnnouncement: @escaping @MainActor (String) -> Void = AppAnnouncer.post, allowsLayoutNotice: @escaping @MainActor (Announcement) -> Bool = { _ in true }, onModeChange: @escaping @MainActor () -> Void ) { self.onModeChange = onModeChange self.postAnnouncement = postAnnouncement self.allowsLayoutNotice = allowsLayoutNotice } func announce(_ announcement: Announcement) { guard allowsLayoutNotice(announcement) else { return } let text: String switch announcement { case .focused: text = AppText.string("Window focused.") case .layoutChanged(let layout): text = AppText.string(layout.rawValue) case .ratioChanged: text = AppText.string("Main window ratio changed.") case .floatingChanged(_, let floating): text = AppText.string(floating ? "Window is floating." : "Window is tiled.") case .stackChanged(_, let count): guard count <= 1 else { return } text = AppText.string("Window stack changed.") case .movedToDisplay: text = AppText.string("Window moved to another display.") case .primaryChanged: text = AppText.string("Window is now primary.") case .windowCapChanged: text = AppText.string("Window count changed.") case .sizesReset: text = AppText.string("Window sizes reset.") case .hoverFocusChanged(let enabled): text = AppText.string(enabled ? "Hover focus is on." : "Hover focus is off.") case .windowsStacked: return case .tilesMerged: return case .undone: text = AppText.string("Window change undone.") case .focusModeChanged(let mode, let enabled): switch (mode, enabled) { case (.focus, true): text = AppText.string("Focus is on.") case (.focus, false): text = AppText.string("Focus is off.") case (.noPeek, true): text = AppText.string("No peek is on.") case (.noPeek, false): text = AppText.string("No peek is off.") case (.cleanSpace, true): text = AppText.string("Clean Space is on.") case (.cleanSpace, false): text = AppText.string("Clean Space is off.") } case .modeChanged(let mode): onModeChange() if let mode { text = AppText.detail("Binding mode %@ activated.", mode).message } else { text = AppText.string("Default binding mode activated.") } } postAnnouncement(text) } static func post(_ text: String) { NSAccessibility.post( element: NSApplication.shared, notification: .announcementRequested, userInfo: [.announcement: text, .priority: NSAccessibilityPriorityLevel.medium.rawValue]) } }