public import Foundation public import ParcelCore public struct EngineCommandSuspensionError: Error, Sendable, Equatable, LocalizedError { public let display: DisplayID public let reason: DisplaySuspension.Reason public var errorDescription: String? { DisplaySuspension(display: display, reason: reason, since: .distantPast).status } } extension ParcelEngine { func commandSuspension( _ command: Command, display: DisplayID?, window: WindowID? = nil, state: State? = nil, nativeWindow: ManagedWindow? = nil ) -> EngineCommandSuspensionError? { let state = state ?? snapshot.state switch command { case .enterMode, .toggleBorders, .toggleHoverFocus: return nil default: break } let targetWindow: WindowID? if case .tileWindow(let tiled) = command { targetWindow = tiled } else { targetWindow = window ?? state.focusedWindow } let source = command.supportsWorkspaceTarget ? display : targetWindow.flatMap { state.workspace(containing: $0)?.display } ?? display guard let source else { return nil } let affected = state.activeSpaces[source].map { state.commandAffectedDisplays( command, from: WorkspaceKey(display: source, space: $0), window: targetWindow) } ?? [source] let exitingNativeFullscreen = command == .toggleFullscreen && nativeWindow?.id == targetWindow && nativeWindow?.facts?.isFullScreen == true for blocked in affected where suspendedDisplays.contains(blocked) { let reasons = displaySuspensions.filter { $0.display == blocked }.map(\.reason) // A verified native exit needs no tile placement, but other unsafe states still block it. let blockingReasons = exitingNativeFullscreen ? reasons.filter { $0 != .fullscreenSpace } : reasons if exitingNativeFullscreen, !reasons.isEmpty, blockingReasons.isEmpty { continue } return EngineCommandSuspensionError( display: blocked, reason: blockingReasons.first ?? .spaceUnavailable) } return nil } func requireCommandDisplay( _ command: Command, display: DisplayID?, window: WindowID? = nil, nativeWindow: ManagedWindow? = nil ) throws { if let failure = commandSuspension(command, display: display, window: window, nativeWindow: nativeWindow) { log.record(.internalFailure(failure)) onFailure?(failure) throw failure } } func suspensionFailure(for event: Event, state: State? = nil) -> EngineCommandSuspensionError? { let state = state ?? snapshot.state switch event { case .commandIssued(let command): return commandSuspension(command, display: state.activeWorkspace?.display, state: state) case .workspaceCommandIssued(let command, let workspace): return commandSuspension(command, display: workspace.display, state: state) case .commandForWindow(let window, let command, let workspace): return commandSuspension( command, display: (workspace ?? state.workspace(containing: window))?.display, window: window, state: state) default: return nil } } }