public func reduce(_ state: State, _ event: Event) -> (State, [Effect]) { let (next, effects) = reduce(state, [event]) return (next, effects.first ?? []) } public enum ReductionStage: Sendable, Equatable { case apply, layout, diff } public enum ReductionPhase: Sendable, Equatable { case begin, end } /// Applies events in order and emits coalesced frame writes. Effects retain their event index. public func reduce( _ state: State, _ events: [Event], trace: ((ReductionStage, ReductionPhase) -> Void)? = nil ) -> (State, [[Effect]]) { reduce(state, events, trace: trace, accepting: nil) } package func reduce( _ state: State, _ events: [Event], trace: ((ReductionStage, ReductionPhase) -> Void)?, accepting: ((State, Event, Int) -> Bool)? ) -> (State, [[Effect]]) { guard !events.isEmpty else { return (state, []) } trace?(.apply, .begin) var next = state next.indexWorkspaces() var effectsByEvent = Array(repeating: [Effect](), count: events.count) var baseline = state.frames var feedbackFrames = events.contains(where: \.isRetile) ? state.frames : nil var retileEvents: [Int] = [] var retileChanges: [WindowID: (event: Int, workspace: WorkspaceKey, frame: Rect)] = [:] var observedInBatch: Set = [] var accepted = false var needsDiff = next.currentLayout == nil var closingNativeTabs: Set = [] for event in events { switch event { case .windowDisappeared(let window), .windowMinimized(let window): closingNativeTabs.insert(window) case .windowAppeared(let window, _, _): closingNativeTabs.remove(window.id) default: break } } for index in state.nativeTabEventOrder(events) { let event = events[index] if accepting?(next, event, index) == false { continue } next.prepareUndoGesture(for: event) let unprepared = event.recordsUndo && next.currentLayout == nil ? next : nil if unprepared != nil { next.adaptWorkspaces(effects: &effectsByEvent[index]) _ = next.materializeLayout() } let previous = event.recordsUndo || event.needsRollback || next.currentLayout == nil ? next : nil let previousMembership = next.focusMembership(for: event) let retileKey = event.retileWorkspace(in: next).flatMap { next.isActive($0) ? $0 : nil } let retileWindows = retileKey.flatMap { next.workspaces[$0]?.tree?.windows } ?? [] next.materializeGeometry(for: event) if let issue = next.handle( event, baseline: &baseline, effects: &effectsByEvent[index], closingNativeTabs: closingNativeTabs) { if let rollback = unprepared ?? previous { next = rollback } effectsByEvent[index] = [.report(issue)] continue } next.indexWorkspaces() next.reconcileFocusModes(previousMembership: previousMembership, effects: &effectsByEvent[index]) needsDiff = needsDiff || next.currentLayout == nil || event.changesBaseline || event.recordsUndo if event.recordsUndo, let previous { let continuesGesture = next.undoGesture?.target == event.undoGestureTarget let scope = event.undoScope(in: previous).union(event.undoScope(in: next)) let before = previous.undoSnapshot(in: scope) _ = next.materializeLayout() let operation = next.recordUndo( previous: before, scope: scope, event: event, effects: effectsByEvent[index], coalescingWith: continuesGesture ? next.undoGesture?.operation : nil) // Tiled frame notifications can arrive between edge samples without changing placement. if operation != nil || continuesGesture { next.undoGesture?.target = event.undoGestureTarget next.undoGesture?.operation = event.undoGestureTarget == nil ? nil : operation } } if feedbackFrames != nil { if let window = event.observedWindow { observedInBatch.insert(window) retileChanges[window] = nil } if let key = event.retileReplacedWorkspace(in: next) { for window in next.workspaces[key]?.tree?.windows ?? [] { observedInBatch.insert(window) retileChanges[window] = nil } } let layout = next.materializeLayout() retileChanges = retileChanges.filter { window, change in layout.frames[window] == change.frame && next.windows[window]?.isFloating == false && next.workspace(containing: window) == change.workspace } if let key = retileKey { retileEvents.append(index) for window in retileWindows { if let frame = layout.frames[window], frame != feedbackFrames?[window] || (retileChanges[window] == nil && !observedInBatch.contains(window) && frame == state.frames[window]) { retileChanges[window] = (index, key, frame) } } } for (window, frame) in layout.frames where feedbackFrames?[window] != frame { feedbackFrames?[window] = frame } } accepted = true } trace?(.apply, .end) guard accepted else { return (next, effectsByEvent) } var effects = events.count == 1 ? effectsByEvent[0] : [] if events.count == 1 { effectsByEvent[0] = [] } trace?(.layout, .begin) var desired = next.materializeLayout() if !desired.cannotFit.isEmpty { next.resolveMinimumCapacity(desired, effects: &effects) desired = next.materializeLayout() needsDiff = true } if needsDiff { for key in next.workspaceKeys where !next.isActive(key) { for window in next.workspaces[key]?.order ?? [] { if let frame = baseline[window], next.frames[window] != frame { next.frames[window] = frame } } } next.cacheLayout(desired) } trace?(.layout, .end) trace?(.diff, .begin) let writes = needsDiff ? desired.frames.compactMap { window, frame -> WindowFrame? in frame != baseline[window] ? WindowFrame(window: window, frame: frame) : nil }.sorted { $0.window < $1.window } : [] next.cannotFit = desired.cannotFit trace?(.diff, .end) if !writes.isEmpty { effects.insert(.setFrames(writes), at: 0) } if next.cannotFit != state.cannotFit && !next.cannotFit.isEmpty { effects.append(.report(.cannotFit(next.cannotFit))) } if needsDiff { next.raiseChangedStacks(previous: state, writes: writes, effects: &effects) } if let focused = next.focusedWindow, next.windows[focused]?.isFloating == true, effects.contains(where: { if case .raiseWindow = $0 { true } else { false } }) { effects.removeAll { $0 == .raiseWindow(focused) } effects.append(.raiseWindow(focused)) } effectsByEvent[0].insert(contentsOf: effects.filter { if case .setFrames = $0 { true } else { false } }, at: 0) effectsByEvent[events.count - 1].append( contentsOf: effects.filter { if case .setFrames = $0 { false } else { true } }) var retileCandidates: [Int: [WindowFrame]] = [:] for (window, change) in retileChanges where next.isActive(change.workspace) && desired.frames[window] == change.frame { retileCandidates[change.event, default: []].append(WindowFrame(window: window, frame: change.frame)) } for index in retileEvents { effectsByEvent[index].append( .confirmRetile(retileCandidates[index, default: []].sorted { $0.window < $1.window })) } return (next, effectsByEvent) } extension Event { fileprivate var observedWindow: WindowID? { switch self { case .windowAppeared(let window, _, _): window.id case .windowMovedByUser(let window, _), .windowResizedByUser(let window, _), .windowFrameEdited(let window, _), .resolveRoom(let window, _, _): window default: nil } } fileprivate func retileReplacedWorkspace(in state: State) -> WorkspaceKey? { switch self { case .commandIssued(let command) where command != .retile && command.affectsWorkspace: state.activeWorkspace case .workspaceCommandIssued(let command, let key) where command != .retile && command.affectsWorkspace: key default: nil } } fileprivate var isRetile: Bool { switch self { case .commandIssued(.retile), .workspaceCommandIssued(.retile, _): true default: false } } fileprivate func retileWorkspace(in state: State) -> WorkspaceKey? { switch self { case .commandIssued(.retile): state.activeWorkspace case .workspaceCommandIssued(.retile, let key): key default: nil } } } extension Size { var isValid: Bool { width.isFinite && height.isFinite && width >= 0 && height >= 0 } } extension Rect { public var isValid: Bool { origin.xCoordinate.isFinite && origin.yCoordinate.isFinite && size.isValid } } extension State { mutating func materializeLayout() -> LayoutResult { if let layout = currentLayout { return layout } let layout = layoutFrames() for (window, frame) in layout.frames where frames[window] != frame { frames[window] = frame } cacheLayout(layout) return layout } fileprivate mutating func materializeGeometry(for event: Event) { guard currentLayout == nil else { return } let window: WindowID? switch event { case .commandIssued(.snap), .commandIssued(.toggleFloat), .commandIssued(.move), .commandIssued(.stack), .commandIssued(.moveToDisplay): window = focusedWindow case .commandIssued(.tileWindow(let target)), .commandForWindow(let target, .toggleFloat, _), .gestureCommitted(.moveToDisplay(let target, _)), .gestureCommitted(.drop(let target, _, _, _)), .gestureCommitted(.floatingFrame(let target, _, _)): window = target default: return } guard let window, windows[window]?.isFloating == false, let key = workspace(containing: window), isActive(key), let display = displays[key.display] else { return } var geometry = self geometry.workspaces[key]?.adapt(to: display.frame, fullFrame: display.fullFrame) frames[window] = geometry.layoutFrames(in: [key]).frames[window] } fileprivate mutating func prepareUndoGesture(for event: Event) { switch event { case .undoGestureBegan: undoGesture = UndoGesture() case .undoGestureEnded, .windowDropped, .gestureCommitted, .commandIssued(.undo): undoGesture = nil case .windowDisappeared(let window), .windowMinimized(let window): if undoGesture?.target == .frame(window) { undoGesture = nil } default: break } } fileprivate func raiseChangedStacks(previous: State, writes: [WindowFrame], effects: inout [Effect]) { for key in workspaceKeys where isActive(key) { let oldStacks = previous.workspaces[key]?.tree?.stacks ?? [] for stack in workspaces[key]?.tree?.stacks ?? [] where stack.windows.count > 1 { let members = Set(stack.windows) let previousGroups = oldStacks.filter { $0.windows.contains(where: members.contains) } let previousMembers = Set(previousGroups.flatMap(\.windows)) let joinedGroups = previousGroups.count > 1 let admittedMember = stack.windows.contains { !previousMembers.contains($0) } if joinedGroups || admittedMember { effects.append(.announce(.windowsStacked(window: stack.visible, count: stack.windows.count))) } let changed = !oldStacks.contains(stack) || writes.contains { stack.windows.contains($0.window) } if changed && !effects.contains(.raiseWindow(stack.visible)) { effects.append(.raiseWindow(stack.visible)) } } } } func layoutFrames() -> LayoutResult { currentLayout ?? layoutFrames(in: Set(workspaceKeys)) } func layoutFrames(in keys: Set) -> LayoutResult { var result = LayoutResult() let activeKeys = workspaceKeys.filter { keys.contains($0) && isActive($0) } for key in activeKeys { guard let workspace = workspaces[key], let display = displays[key.display] else { continue } let layout = LayoutEngine.arrange(workspace, in: display.frame, windows: windows) for (window, frame) in layout.frames where windows[window]?.isFloating == false { result.frames[window] = frame } result.visibleWindows += layout.visibleWindows if let focused = modes(for: key).focusedWindow, self.workspace(containing: focused) == key, windows[focused]?.isFloating == false, let frame = focusFrame(in: key) { result.frames[focused] = frame result.cannotFit += layout.cannotFit.filter { $0 != focused } if let minimum = windows[focused]?.minimumSize, minimum.width > frame.size.width || minimum.height > frame.size.height { result.cannotFit.append(focused) } } else { result.cannotFit += layout.cannotFit } } for key in activeKeys { for window in workspaces[key]?.order ?? [] where windows[window]?.isFloating == true { if let frame = frames[window] { result.frames[window] = frame } } } result.cannotFit.sort() return result } mutating func focus(_ window: WindowID, requestingFocus: Bool = true, effects: inout [Effect]) { guard let key = workspace(containing: window), isActive(key), let managed = windows[window] else { return } let changed = focusedWindow != window let observingAuxiliary = !requestingFocus && managed.isFloatingAuxiliary if changed { if let previous = focusedWindow, let oldKey = workspace(containing: previous), oldKey != key, isActive(oldKey) { endFocus(in: oldKey, effects: &effects) } if let expanded = modes(for: key).focusedWindow, expanded != window, !(observingAuxiliary && windows[expanded]?.app == managed.app) { endFocus(in: key, effects: &effects) } } focusedWindow = window activeDisplay = key.display // An auxiliary can own keyboard focus while the document stays selected in its layout. if !observingAuxiliary { selectWindow(window, in: key) } if changed { if requestingFocus { effects.append(.focusWindow(window)) } if !observingAuxiliary { effects.append(.raiseWindow(window)) } effects.append(.announce(.focused(window))) } } mutating func transfer(_ window: WindowID, to destination: WorkspaceKey, effects: inout [Effect]) { guard let source = workspace(containing: window), source != destination else { return } endFocus(in: source, effects: &effects) endFocus(in: destination, effects: &effects) modifyWorkspace(source) { $0.remove(window) } var workspace = workspaces[destination] ?? newWorkspace(destination) let wasFloating = windows[window]?.isFloating == true insertWindow( window, into: &workspace, floating: wasFloating, frame: frames[window] ?? observedFrames[window] ?? Rect(), effects: &effects) setWorkspace(workspace) if wasFloating { relocateFloating(window, to: destination.display) } if focusedWindow == window { activeDisplay = destination.display } } mutating func relocateFloating(_ window: WindowID, to display: DisplayID) { guard windows[window]?.isFloating == true, let previous = frames[window], let screen = displays[display]?.frame else { return } frames[window] = Rect( x: screen.minX + max(0, (screen.size.width - previous.size.width) / 2), y: screen.minY + max(0, (screen.size.height - previous.size.height) / 2), width: min(screen.size.width, previous.size.width), height: min(screen.size.height, previous.size.height) ).roundedToWholePoints() } func neighbor( of window: WindowID, direction: Direction, tiledOnly: Bool = false, within workspace: WorkspaceKey? = nil ) -> WindowID? { let geometry = currentLayout != nil ? frames : layoutFrames().frames.merging(frames) { target, _ in target } guard let source = geometry[window] else { return nil } var nearest: (window: WindowID, distance: DirectionalDistance)? for candidate in visibleWindows where candidate != window && (!tiledOnly || windows[candidate]?.isFloating == false) && (workspace == nil || self.workspace(containing: candidate) == workspace) { guard let frame = geometry[candidate], let distance = direction.distance(from: source, to: frame) else { continue } if let best = nearest, best.distance < distance || (best.distance == distance && best.window < candidate) { continue } nearest = (candidate, distance) } return nearest?.window } func displayNeighbor(from display: DisplayID, direction: Direction) -> DisplayID? { guard let source = displays[display]?.frame else { return nil } return displays.keys.filter { $0 != display }.compactMap { candidate -> (DisplayID, DirectionalDistance)? in guard let frame = displays[candidate]?.frame, let distance = direction.distance(from: source, to: frame) else { return nil } return (candidate, distance) }.min { $0.1 == $1.1 ? $0.0 < $1.0 : $0.1 < $1.1 }?.0 } }