public struct SetupOpening: Sendable, Equatable { public enum Phase: Sendable, Equatable { case opening, finished, cancelled } public enum MissingReason: Sendable, Equatable { case disconnectedDisplay, inactiveSpace, suspendedDisplay, ambiguous, notFound, identityChanged } public struct MissingWindow: Sendable, Equatable { public let window: WorkspaceMemory.SavedWindow public let workspace: WorkspaceKey public let reason: MissingReason } public struct MissingWorkspace: Sendable, Equatable { public let workspace: WorkspaceKey public let reason: MissingReason } private struct Pin: Sendable, Equatable { let id: WindowID let app: AppID let role: String let subrole: String? func matches(_ window: ManagedWindow?) -> Bool { window.map { $0.id == id && $0.app == app && $0.role == role && $0.subrole == subrole } == true } } public let setup: SavedSetup public private(set) var phase: Phase = .opening public private(set) var missingWindows: [MissingWindow] = [] public private(set) var missingWorkspaces: [MissingWorkspace] = [] public private(set) var matchedWindows: [WindowID: WindowID] = [:] private var baseline: State private var scope = UndoScope() private var pins: [WindowID: Pin] = [:] private var retired: Set = [] public var isFinished: Bool { phase != .opening } public var unresolvedCount: Int { missingWindows.count + missingWorkspaces.filter { missing in !missingWindows.contains { $0.workspace == missing.workspace } }.count } public var pendingBundleIDs: [String] { guard !isFinished else { return [] } return Set( missingWindows.filter { $0.reason == .notFound || $0.reason == .ambiguous } .map { $0.window.bundleID } ).sorted() } public init(setup: SavedSetup, state: State) throws { try setup.validate() self.setup = setup let keys = Set(state.workspaces.keys.filter { state.isActive($0) }) baseline = state.undoSnapshot(in: UndoScope(workspaces: keys)) refreshMissing( in: state, mapping: setup.memory.windowMapping(in: state, acrossDisplays: true, activeOnly: true)) } /// Feed lifecycle notifications before applying the reduced state; a closed pin is never rebound. public mutating func observe(_ event: Event) { guard !isFinished else { return } switch event { case .windowDisappeared(let id), .windowMinimized(let id): retirePins(for: id) baseline = reduce(baseline, .windowDisappeared(id)).0 default: break } } public mutating func apply(to state: inout State) -> [Effect] { guard !isFinished else { return [] } synchronizeBaseline(with: state) for (token, pin) in pins where !pin.matches(state.windows[pin.id]) { retired.insert(token) } let pinned = pins.mapValues(\.id) var mapping = setup.memory.windowMapping(in: state, pinned: pinned, acrossDisplays: true, activeOnly: true) mapping = mapping.filter { !retired.contains($0.key) } for (token, id) in mapping where pins[token] == nil { guard let window = state.windows[id] else { continue } pins[token] = Pin(id: id, app: window.app, role: window.role, subrole: window.subrole) } matchedWindows = mapping refreshMissing(in: state, mapping: mapping) let targets = Set( setup.memory.records.map { $0.workspace.key }.filter { state.isActive($0) && state.displays[$0.display]?.hasUsableGeometry == true }) guard !targets.isEmpty else { return [] } let sources = Set(mapping.values.compactMap { state.workspace(containing: $0) }) scope.workspaces.formUnion(targets.union(sources)) scope.windows.formUnion(mapping.values) var effects: [Effect] = [] let previousFrames = state.frames for key in targets.union(sources).sorted() { state.endFocus(in: key, effects: &effects) } let restored = setup.memory.restoring(state, mapping: mapping, restoringTiling: true, activeOnly: true) let (next, layoutEffects) = reduce(restored, .relayout) state = next effects.append(contentsOf: layoutEffects.filter { if case .setFrames = $0 { false } else { true } }) // Restoration may set floating geometry before reduction; diff against the caller's original frames. let writes = state.frames.compactMap { id, frame -> WindowFrame? in guard previousFrames[id] != frame, let key = state.workspace(containing: id), state.isActive(key) else { return nil } return WindowFrame(window: id, frame: frame) }.sorted { $0.window < $1.window } if !writes.isEmpty { effects.insert(.setFrames(writes), at: 0) } return effects } /// One history entry covers the initial placements and every surviving delayed arrival. public mutating func finish(in state: inout State) -> [Effect] { guard !isFinished else { return [] } let effects = apply(to: &state) let before = baseline.undoSnapshot(in: scope) _ = state.materializeLayout() _ = state.recordUndo( previous: before, scope: scope, event: .relayout, effects: [], coalescingWith: nil, includeAllWorkspaceSettings: true) phase = .finished return effects } /// Cancellation stops restoration, retaining the partial result and its single placement undo. public mutating func cancel(in state: inout State) -> [Effect] { guard !isFinished else { return [] } synchronizeBaseline(with: state) let before = baseline.undoSnapshot(in: scope) _ = state.materializeLayout() _ = state.recordUndo( previous: before, scope: scope, event: .relayout, effects: [], coalescingWith: nil, includeAllWorkspaceSettings: true) phase = .cancelled return [] } private mutating func retirePins(for id: WindowID) { for (token, pin) in pins where pin.id == id { retired.insert(token) } } private mutating func synchronizeBaseline(with state: State) { let previousScope = scope scope.workspaces = scope.workspaces.filter { state.isActive($0) } var rebased: Set = [] for id in baseline.windows.keys.sorted() { guard let before = baseline.windows[id] else { continue } if state.windows[id]?.app != before.app { retirePins(for: id) baseline = reduce(baseline, .windowDisappeared(id)).0 } else if let original = baseline.workspace(containing: id), let current = state.workspace(containing: id) { let safeCrossDisplay = original.display != current.display && state.isActive(original) && state.isActive(current) && state.displays[original.display]?.hasUsableGeometry == true && state.displays[current.display]?.hasUsableGeometry == true let touched = previousScope.workspaces.contains(original) || previousScope.windows.contains(id) if touched && (!state.isActive(original) || (original.space != current.space && !safeCrossDisplay)) { // Undo cannot send a survivor back into a departed display or inactive native Space. rebased.insert(id) scope.windows.remove(id) baseline = reduce(baseline, .windowDisappeared(id)).0 } else if safeCrossDisplay { scope.workspaces.formUnion([original, current]) } } } for id in state.windows.keys.sorted() where baseline.windows[id] == nil { guard let window = state.windows[id], let key = state.workspace(containing: id), let display = state.displays[key.display] else { continue } baseline.displays[key.display] = display baseline.activeSpaces[key.display] = state.activeSpaces[key.display] let frame = rebased.contains(id) ? (state.frames[id] ?? state.observedFrames[id] ?? display.frame) : (state.observedFrames[id] ?? state.frames[id] ?? display.frame) baseline = reduce(baseline, .windowAppeared(window, workspace: key, frame: frame)).0 } } private mutating func refreshMissing(in state: State, mapping: [WindowID: WindowID]) { missingWorkspaces = setup.memory.records.compactMap { record in let key = record.workspace.key let reason: MissingReason if state.displays[key.display] == nil { reason = .disconnectedDisplay } else if !state.isActive(key) { reason = .inactiveSpace } else if state.displays[key.display]?.hasUsableGeometry != true { reason = .suspendedDisplay } else { return nil } return MissingWorkspace(workspace: key, reason: reason) } missingWindows = setup.memory.records.flatMap { record in record.windows.compactMap { window -> MissingWindow? in let key = record.workspace.key let reason: MissingReason if state.displays[key.display] == nil { reason = .disconnectedDisplay } else if !state.isActive(key) { reason = .inactiveSpace } else if state.displays[key.display]?.hasUsableGeometry != true { reason = .suspendedDisplay } else if retired.contains(window.token) { reason = .identityChanged } else if mapping[window.token] != nil { return nil } else if !setup.memory.identityCandidates(for: window, workspace: key, in: state).isEmpty { reason = .ambiguous } else { reason = .notFound } return MissingWindow(window: window, workspace: key, reason: reason) } } } } extension State { public mutating func applySetupOpening(_ opening: inout SetupOpening) -> [Effect] { opening.apply(to: &self) } }