private struct StateCache: Sendable, Equatable { var value: Value? // Derived caches are neither persisted nor part of model equality. static func == (_ lhs: Self, _ rhs: Self) -> Bool { true } } private struct EdgeValidation: Sendable { let edge: TileEdge let minimums: TileEdgeMinimums let tree: TileTree? let layout: Layout let gaps: Gaps let reservedEdges: Insets let screen: Rect } public struct MinimizedPlacement: Sendable, Equatable, Codable { public internal(set) var window: ManagedWindow public internal(set) var workspace: Workspace public internal(set) var removed: [WindowID] } public struct State: Sendable, Equatable, Codable { public var windows: [WindowID: ManagedWindow] { didSet { invalidateGeometry() } } public var displays: [DisplayID: Display] { didSet { invalidateGeometry() } } public var activeSpaces: [DisplayID: SpaceID] { didSet { invalidateGeometry() } } public var workspaces: [WorkspaceKey: Workspace] { didSet { windowWorkspace.value = nil orderedKeys.value = nil invalidateLayout() } } public var activeDisplay: DisplayID? public var focusedWindow: WindowID? public var activeMode: String? public var focusModes: [WorkspaceKey: FocusModes]? { didSet { invalidateLayout() } } public var frames: [WindowID: Rect] { didSet { invalidateLayout() } } public var observedFrames: [WindowID: Rect] public var snapHistory: [WindowID: SnapHistory]? public var undoHistory: UndoHistory? public var undoGesture: UndoGesture? public var minimizedPlacements: [WindowID: MinimizedPlacement]? public var cannotFit: [WindowID] private var hoverFocus: Bool? private var displayFullPolicy: WhenDisplayFull? public var layoutDefaults: LayoutDefaults? public var displayLayoutDefaults: [DisplayID: LayoutDefaults]? private var windowWorkspace = StateCache<[WindowID: WorkspaceKey]>() private var orderedKeys = StateCache<[WorkspaceKey]>() private var layoutCache = StateCache() private var edgeValidation = StateCache() private enum CodingKeys: String, CodingKey { case windows, displays, activeSpaces, workspaces, activeDisplay, focusedWindow, activeMode, focusModes case frames, observedFrames, snapHistory, undoHistory, undoGesture, minimizedPlacements, cannotFit case hoverFocus, layoutDefaults, displayLayoutDefaults case displayFullPolicy = "whenDisplayFull" } public var whenDisplayFull: WhenDisplayFull { get { displayFullPolicy ?? .swap } set { displayFullPolicy = newValue == .swap ? nil : newValue } } public var hoverFocusEnabled: Bool { get { hoverFocus == true } set { hoverFocus = newValue ? true : nil } } public init( displays: [Display] = [], activeSpaces: [DisplayID: SpaceID] = [:], workspaces: [WorkspaceKey: Workspace] = [:], windows: [WindowID: ManagedWindow] = [:], activeDisplay: DisplayID? = nil, focusedWindow: WindowID? = nil, frames: [WindowID: Rect] = [:], observedFrames: [WindowID: Rect] = [:], activeMode: String? = nil, layoutDefaults: LayoutDefaults = LayoutDefaults(), displayLayoutDefaults: [DisplayID: LayoutDefaults] = [:], whenDisplayFull: WhenDisplayFull = .swap ) { self.displays = Dictionary(uniqueKeysWithValues: displays.map { ($0.id, $0) }) self.activeSpaces = activeSpaces self.workspaces = workspaces self.windows = windows self.activeDisplay = activeDisplay ?? displays.first?.id self.focusedWindow = focusedWindow self.activeMode = activeMode focusModes = nil self.frames = frames self.observedFrames = observedFrames snapHistory = nil undoHistory = nil undoGesture = nil minimizedPlacements = nil cannotFit = [] hoverFocus = nil displayFullPolicy = whenDisplayFull == .swap ? nil : whenDisplayFull self.layoutDefaults = layoutDefaults self.displayLayoutDefaults = displayLayoutDefaults for display in displays { if let space = activeSpaces[display.id] { let key = WorkspaceKey(display: display.id, space: space) if self.workspaces[key] == nil { self.workspaces[key] = newWorkspace(key) } } } for key in self.workspaces.keys { if let display = self.displays[key.display], display.hasUsableGeometry { self.workspaces[key]?.adapt(to: display.frame, fullFrame: display.fullFrame) } } } public init(from decoder: any Decoder) throws { let values = try decoder.container(keyedBy: CodingKeys.self) windows = try values.decode([WindowID: ManagedWindow].self, forKey: .windows) displays = try values.decode([DisplayID: Display].self, forKey: .displays) activeSpaces = try values.decode([DisplayID: SpaceID].self, forKey: .activeSpaces) workspaces = try values.decode([WorkspaceKey: Workspace].self, forKey: .workspaces) activeDisplay = try values.decodeIfPresent(DisplayID.self, forKey: .activeDisplay) focusedWindow = try values.decodeIfPresent(WindowID.self, forKey: .focusedWindow) activeMode = try values.decodeIfPresent(String.self, forKey: .activeMode) focusModes = try values.decodeIfPresent([WorkspaceKey: FocusModes].self, forKey: .focusModes) frames = try values.decode([WindowID: Rect].self, forKey: .frames) observedFrames = try values.decode([WindowID: Rect].self, forKey: .observedFrames) snapHistory = try values.decodeIfPresent([WindowID: SnapHistory].self, forKey: .snapHistory) undoHistory = try values.decodeIfPresent(UndoHistory.self, forKey: .undoHistory) undoGesture = try values.decodeIfPresent(UndoGesture.self, forKey: .undoGesture) minimizedPlacements = try values.decodeIfPresent( [WindowID: MinimizedPlacement].self, forKey: .minimizedPlacements) cannotFit = try values.decode([WindowID].self, forKey: .cannotFit) hoverFocus = try values.decodeIfPresent(Bool.self, forKey: .hoverFocus) layoutDefaults = try values.decodeIfPresent(LayoutDefaults.self, forKey: .layoutDefaults) displayLayoutDefaults = try values.decodeIfPresent( [DisplayID: LayoutDefaults].self, forKey: .displayLayoutDefaults) let policy = try values.decodeIfPresent(WhenDisplayFull.self, forKey: .displayFullPolicy) ?? .swap displayFullPolicy = policy == .swap ? nil : policy } public var activeWorkspace: WorkspaceKey? { guard let display = activeDisplay, let space = activeSpaces[display] else { return nil } return WorkspaceKey(display: display, space: space) } public func workspace(containing window: WindowID) -> WorkspaceKey? { if let index = windowWorkspace.value { return index[window] } return workspaces.lazy.filter { $0.value.order.contains(window) }.map(\.key).min() } var workspaceKeys: [WorkspaceKey] { orderedKeys.value ?? workspaces.keys.sorted() } var currentLayout: LayoutResult? { layoutCache.value } mutating func invalidateLayout() { layoutCache.value = nil } private mutating func invalidateGeometry() { invalidateLayout() edgeValidation.value = nil } mutating func cacheLayout(_ layout: LayoutResult) { layoutCache.value = layout } func hasValidatedEdge(_ edge: TileEdge, in workspace: Workspace, screen: Rect) -> Bool { guard let previous = edgeValidation.value else { return false } return previous.edge == edge && previous.tree == workspace.tree && previous.layout == workspace.layout && previous.gaps == workspace.gaps && previous.reservedEdges == workspace.reservedEdges && previous.screen == screen } func validatedEdgeMinimums(_ edge: TileEdge, in workspace: Workspace, screen: Rect) -> TileEdgeMinimums? { hasValidatedEdge(edge, in: workspace, screen: screen) ? edgeValidation.value?.minimums : nil } mutating func recordValidatedEdge( _ edge: TileEdge, minimums: TileEdgeMinimums, in workspace: Workspace, screen: Rect ) { edgeValidation.value = EdgeValidation( edge: edge, minimums: minimums, tree: workspace.tree, layout: workspace.layout, gaps: workspace.gaps, reservedEdges: workspace.reservedEdges, screen: screen) } mutating func indexWorkspaces() { if orderedKeys.value == nil { orderedKeys.value = workspaces.keys.sorted() } guard windowWorkspace.value == nil else { return } var index: [WindowID: WorkspaceKey] = [:] index.reserveCapacity(windows.count) for key in workspaceKeys { for window in workspaces[key]?.order ?? [] where index[window] == nil { index[window] = key } } windowWorkspace.value = index } mutating func setWorkspace(_ workspace: Workspace, preservingGeometry: Bool = false) { let key = workspace.key let previousOrder = workspaces[key]?.order var index = windowWorkspace var keys = orderedKeys let layout = layoutCache workspaces[key] = workspace if previousOrder == nil { keys.value = keys.value.map { ($0 + [key]).sorted() } } orderedKeys = keys if previousOrder != workspace.order, index.value != nil { let members = Set(workspace.order) for window in previousOrder ?? [] where !members.contains(window) && index.value?[window] == key { index.value?[window] = workspaceKeys.first { workspaces[$0]?.order.contains(window) == true } } for window in workspace.order { let owner = min(index.value?[window] ?? key, key) index.value?[window] = owner } } windowWorkspace = index if preservingGeometry { layoutCache = layout } } mutating func modifyWorkspace( _ key: WorkspaceKey, preservingGeometry: Bool = false, _ update: (inout Workspace) -> Void ) { guard var workspace = workspaces[key] else { return } update(&workspace) setWorkspace(workspace, preservingGeometry: preservingGeometry) } mutating func recordFrame(_ frame: Rect, for window: WindowID) { var layout = layoutCache.value frames[window] = frame if windows[window]?.isFloating == true, let key = workspace(containing: window), isActive(key) { layout?.frames[window] = frame layoutCache.value = layout } } mutating func applyWorkspaceLayout(_ workspace: Workspace, layout replacement: LayoutResult) { let layout = currentLayout setWorkspace(workspace) guard var layout else { return } for window in workspace.order where windows[window]?.isFloating == false { layout.frames[window] = replacement.frames[window] } layout.visibleWindows = workspaceKeys.filter(isActive).flatMap { workspaces[$0]?.visibleWindows ?? [] } layout.cannotFit.removeAll { self.workspace(containing: $0) == workspace.key } layout.cannotFit += replacement.cannotFit layout.cannotFit.sort() for (window, frame) in replacement.frames where windows[window]?.isFloating == false && frames[window] != frame { frames[window] = frame } cacheLayout(layout) } mutating func selectWindow(_ window: WindowID, in key: WorkspaceKey) { let previous = workspaces[key]?.tree?.stack(containing: window)?.visible let preservesGeometry = workspaces[key]?.layout != .accordion modifyWorkspace(key, preservingGeometry: preservesGeometry) { workspace in workspace.focus = window if let previous, previous != window { workspace.tree = workspace.tree?.mappingStacks { stack in var selected = stack selected.select(window) return selected } } } if preservesGeometry, let previous, previous != window, let index = layoutCache.value?.visibleWindows.firstIndex(of: previous) { layoutCache.value?.visibleWindows[index] = window } } public func isActive(_ key: WorkspaceKey) -> Bool { displays[key.display] != nil && activeSpaces[key.display] == key.space } public var tileEdges: [TileEdge] { workspaceKeys.filter(isActive).flatMap { key in guard let workspace = workspaces[key], let display = displays[key.display] else { return [TileEdge]() } guard modes(for: key).focusedWindow == nil else { return [] } return LayoutEngine.edges(workspace, in: display.frame, windows: windows) } } public var visibleWindows: [WindowID] { var result: [WindowID] = [] result.reserveCapacity(windows.count) for key in workspaceKeys where isActive(key) { guard let workspace = workspaces[key] else { continue } workspace.tree?.appendVisibleWindows(to: &result) for window in workspace.order where windows[window]?.isFloating == true { result.append(window) } } return result } } public enum Command: Sendable, Equatable, Codable { case focus(Direction) case swap(Direction) case move(Direction) case cycleLayout case setLayout(Layout) case setRatio(MainRatio) case nudgeRatio(Double) case toggleFloat case tileWindow(WindowID) case snap(SnapAction) case retile case makePrimary case focusNextWindow case focusPreviousWindow case resetSizes case close case toggleFullscreen case alwaysFloat case undoLastRule case toggleFocus case toggleNoPeek case toggleCleanSpace case toggleBorders case toggleHoverFocus case undo case moveToDisplay(Direction) case stack(Direction) case unstack case focusNextInStack case focusPreviousInStack case setWindowCap(Int) case split(Axis) case join(Direction) case balance case rotate case mirror(Axis) case enterMode(String?) } public enum Event: Sendable, Equatable, Codable { case relayout case windowAppeared(ManagedWindow, workspace: WorkspaceKey, frame: Rect) case windowDisappeared(WindowID) case windowMinimized(WindowID) case windowMovedByUser(WindowID, frame: Rect) case windowResizedByUser(WindowID, frame: Rect) case windowFrameEdited(WindowID, frame: Rect) case undoGestureBegan case undoGestureEnded case windowDropped(source: WindowID, target: WindowID, stacking: Bool) case gestureCommitted(WindowGesture) case tileEdgeResized(TileEdge, delta: Double) case tileEdgeReset(TileEdge) case focusChanged(WindowID?) case windowDragBegan(WindowID) case sessionSuspended(Set) case displaySetChanged([Display]) case activeSpaceChanged(display: DisplayID, space: SpaceID) case commandIssued(Command) case commandForWindow(WindowID, Command, workspace: WorkspaceKey? = nil) case hoverFocusConfigured(Bool) case hoverFocusSettled(WindowID, workspace: WorkspaceKey) case workspaceCommandIssued(Command, workspace: WorkspaceKey) case minimumSizeChanged(WindowID, minimum: LearnedMinimumSize?) case resolveRoom(window: WindowID, workspace: WorkspaceKey, action: RoomResolution) } public struct WindowFrame: Sendable, Equatable, Codable { public let window: WindowID public let frame: Rect public init(window: WindowID, frame: Rect) { self.window = window self.frame = frame } } // The UI turns these semantic messages into localized strings from its catalog. public enum Announcement: Sendable, Equatable, Codable { case focused(WindowID) case layoutChanged(Layout) case ratioChanged(MainRatio) case floatingChanged(WindowID, isFloating: Bool) case stackChanged(window: WindowID, count: Int) case movedToDisplay(WindowID, DisplayID) case modeChanged(String?) case focusModeChanged(FocusMode, enabled: Bool) case primaryChanged(WindowID) case windowCapChanged(Int) case tilesMerged(count: Int, limit: Int) case windowsStacked(window: WindowID, count: Int) case sizesReset case hoverFocusChanged(Bool) case undone(WindowID) } public enum Report: Sendable, Equatable, Codable { case retiled(moved: Int) case cannotFit([WindowID]) case unknownWindow(WindowID) case invalidDropTarget(WindowID) case unavailableDisplay(DisplayID) case noActiveWorkspace case noFocusedWindow case noNeighbor(Direction) case atWindowCap(Int) case layoutCapabilityLimit(layout: Layout, maximum: Int) case invalidGeometry case noSnapHistory case noUndoHistory case undoConflict(WindowID) case noOtherDisplay case invalidRatio case unsupportedMinimumVersion(Int) case maximumSizeReached case minimumSizeReached case spaceFull(WindowID) case minimizedPlacementChanged(WindowID) case invalidWindowCap(Int) case notTiled(WindowID) case unsupported } public enum Effect: Sendable, Equatable, Codable { case setFrames([WindowFrame]) /// Candidates for read-back confirmation, not a count of successful movement. case confirmRetile([WindowFrame]) case focusWindow(WindowID) case raiseWindow(WindowID) case closeWindow(WindowID) case toggleFullscreen(WindowID) case saveFloatingRule(WindowID) case undoLastRule case announce(Announcement) case report(Report) }