import CryptoKit public import Foundation public enum WorkspaceMemoryError: Error, Sendable, Equatable { case duplicateWorkspace(WorkspaceKey) case duplicateWindowToken(WindowID) case invalidWorkspace(WorkspaceKey) case invalidWindow(WindowID) case invalidTitleSalt case invalidTimestamp case invalidPruningPolicy case windowTokensExhausted } public struct WorkspaceMemory: Sendable, Equatable, Codable { public struct SavedWindow: Sendable, Equatable, Codable { public let token: WindowID public let bundleID: String public let titleDigest: String? public let role: String public let subrole: String? public let display: DisplayID public let isFloating: Bool public let normalizedFloatingFrame: Rect? public init( token: WindowID, bundleID: String, titleDigest: String?, role: String = "AXWindow", subrole: String? = nil, display: DisplayID, isFloating: Bool = false, normalizedFloatingFrame: Rect? = nil ) { self.token = token self.bundleID = bundleID self.titleDigest = titleDigest self.role = role self.subrole = subrole self.display = display self.isFloating = isFloating self.normalizedFloatingFrame = normalizedFloatingFrame } fileprivate func retokened(_ token: WindowID) -> SavedWindow { SavedWindow( token: token, bundleID: bundleID, titleDigest: titleDigest, role: role, subrole: subrole, display: display, isFloating: isFloating, normalizedFloatingFrame: normalizedFloatingFrame) } } public struct Record: Sendable, Equatable, Codable { public let workspace: Workspace public let windows: [SavedWindow] public let lastSeen: TimeInterval public init(workspace: Workspace, windows: [SavedWindow] = [], lastSeen: TimeInterval = 0) { self.workspace = workspace self.windows = windows self.lastSeen = lastSeen } public func retainingApplications(_ bundleIDs: Set) -> Record { let retained = windows.filter { bundleIDs.contains($0.bundleID) } var mapping: [WindowID: WindowID] = [:] for window in retained { mapping[window.token] = window.token } return Record(workspace: workspace.memoryRemapping(mapping), windows: retained, lastSeen: lastSeen) } private enum CodingKeys: String, CodingKey { case workspace, windows, lastSeen } private struct RatioCheck: Decodable { let key: WorkspaceKey let ratio: Double let configuredRatio: Double? } public init(from decoder: any Decoder) throws { let container = try decoder.container(keyedBy: CodingKeys.self) let check = try container.decode(RatioCheck.self, forKey: .workspace) guard check.ratio.isFinite, MainRatio.bounds.contains(check.ratio), check.configuredRatio.map({ $0.isFinite && MainRatio.bounds.contains($0) }) != false else { throw WorkspaceMemoryError.invalidWorkspace(check.key) } var workspace = try container.decode(Workspace.self, forKey: .workspace) workspace.restoreAutomaticTiles() self.workspace = workspace windows = try container.decode([SavedWindow].self, forKey: .windows) lastSeen = try container.decode(TimeInterval.self, forKey: .lastSeen) } public func mergingMissingWindows( from previous: Record, tokens: Set, maximumCount: Int = 128 ) throws -> Record { guard maximumCount >= 0 else { throw WorkspaceMemoryError.invalidPruningPolicy } guard workspace.key == previous.workspace.key else { throw WorkspaceMemoryError.invalidWorkspace(previous.workspace.key) } let members = Set(workspace.order) let missing = previous.windows.filter { tokens.contains($0.token) && !members.contains($0.token) } guard missing.count <= maximumCount else { throw WorkspaceMemoryError.invalidWorkspace(workspace.key) } guard !missing.isEmpty else { return self } guard Set(missing.map(\.token)).count == missing.count else { throw WorkspaceMemoryError.invalidWorkspace(previous.workspace.key) } let focus = workspace.focus let savedByToken = Dictionary(uniqueKeysWithValues: missing.map { ($0.token, $0) }) func merging(into source: Workspace, from savedTree: TileTree?) -> Workspace { var merged = source for token in previous.workspace.order { guard let window = savedByToken[token] else { continue } let next = previous.workspace.order.drop { $0 != token }.dropFirst().first { merged.order.contains($0) } let position = next.flatMap { merged.order.firstIndex(of: $0) } let savedStack = savedTree?.stacks.first { $0.windows.contains(token) } let anchor = savedStack?.windows.first { merged.tree?.windows.contains($0) == true } if !window.isFloating, let anchor, let tree = merged.tree { merged.insert(token, floating: true, in: nil, windows: [:], position: position) merged.tree = tree.mappingStacks { stack in guard stack.windows.contains(anchor) else { return stack } var updated = stack updated.append(token) return updated } } else { merged.insert(token, floating: window.isFloating, in: nil, windows: [:], position: position) } if savedStack?.isUserMade == true { merged.tree = merged.tree?.mappingStacks { stack in guard stack.windows.contains(token) else { return stack } var marked = stack marked.isUserMade = true return marked } } } if let focus { merged.select(focus) } else { merged.focus = nil } return merged } var expanded = workspace expanded.restoreAdaptiveTiles() expanded.displaySize = nil expanded.capabilitySize = nil expanded.setWindowCap(Int.max) expanded = merging( into: expanded, from: previous.workspace.adaptiveTileMemory?.original ?? previous.workspace.tree) var merged = workspace merged.adaptiveTileMemory = nil merged = merging(into: merged, from: previous.workspace.tree) // Projection stacks must not erase a missing window's separate expandable slot. if let original = expanded.tree, let projection = merged.tree, original.tileCount > projection.tileCount { merged.adaptiveTileMemory = AdaptiveTileMemory(original: original, projection: projection) } merged.pendingSplitAxis = workspace.pendingSplitAxis return Record(workspace: merged, windows: windows + missing, lastSeen: lastSeen) } } public let records: [Record] public let titleSalt: Data public init(titleSalt: Data = Data()) { records = [] self.titleSalt = titleSalt } public init(records: [Record], titleSalt: Data) throws { self.records = records.sorted { $0.workspace.key < $1.workspace.key } self.titleSalt = titleSalt try validate() } private enum CodingKeys: String, CodingKey { case records, titleSalt } public init(from decoder: any Decoder) throws { let container = try decoder.container(keyedBy: CodingKeys.self) try self.init( records: container.decode([Record].self, forKey: .records), titleSalt: container.decode(Data.self, forKey: .titleSalt)) } public func titleDigest(for title: String) throws -> String? { guard titleSalt.count == 32 else { throw WorkspaceMemoryError.invalidTitleSalt } return Self.digest(title, salt: titleSalt) } public func pruned( asOf now: TimeInterval, maximumAge: TimeInterval = 30 * 24 * 60 * 60, maximumCount: Int = 128 ) throws -> WorkspaceMemory { guard now.isFinite, now >= 0 else { throw WorkspaceMemoryError.invalidTimestamp } guard maximumAge.isFinite, maximumAge >= 0, maximumCount >= 0 else { throw WorkspaceMemoryError.invalidPruningPolicy } let retained = records.filter { now - $0.lastSeen <= maximumAge }.sorted { if $0.lastSeen != $1.lastSeen { return $0.lastSeen > $1.lastSeen } return $0.workspace.key < $1.workspace.key } return try WorkspaceMemory(records: Array(retained.prefix(maximumCount)), titleSalt: titleSalt) } public func validate() throws { guard titleSalt.count == 32 || (titleSalt.isEmpty && records.allSatisfy({ $0.windows.isEmpty })) else { throw WorkspaceMemoryError.invalidTitleSalt } var keys: Set = [] var tokens: Set = [] for record in records { guard record.lastSeen.isFinite, record.lastSeen >= 0 else { throw WorkspaceMemoryError.invalidTimestamp } let workspace = record.workspace let key = workspace.key guard keys.insert(key).inserted else { throw WorkspaceMemoryError.duplicateWorkspace(key) } let members = Set(workspace.order) guard !key.display.rawValue.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty, key.space.rawValue > 0, workspace.windowCap > 0, workspace.ratio.value.isFinite, MainRatio.bounds.contains(workspace.ratio.value), Self.validLength(workspace.gaps.inner), Self.validInsets(workspace.gaps.outer), Self.validInsets(workspace.reservedEdges), members.count == workspace.order.count, Set(workspace.openingOrder) == members, workspace.openingOrder.count == members.count, workspace.focus.map(members.contains) != false, workspace.displaySize.map(Self.validSize) != false, workspace.capabilitySize.map(Self.validSize) != false, (workspace.capabilitySize ?? workspace.displaySize).map({ workspace.layout.capabilities(in: Rect(origin: Point(), size: $0)).variant == workspace.layoutVariant }) != false, Self.validTree(workspace.tree, members: members, cap: workspace.effectiveWindowCap), Self.validTree(workspace.alternateSideTree, members: members, cap: Int.max), workspace.adaptiveTileMemory.map({ memory in Self.validTree(memory.original, members: members, cap: Int.max) && Self.validTree(memory.projection, members: members, cap: workspace.effectiveWindowCap) && Set(memory.original.windows) == Set(workspace.tree?.windows ?? []) && Set(memory.projection.windows) == Set(workspace.tree?.windows ?? []) }) != false, record.windows.count == members.count, Set(record.windows.map(\.token)) == members else { throw WorkspaceMemoryError.invalidWorkspace(key) } var tiled: Set = [] for window in record.windows { guard tokens.insert(window.token).inserted else { throw WorkspaceMemoryError.duplicateWindowToken(window.token) } guard window.token.rawValue > 0, window.display == key.display, !window.bundleID.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty, window.titleDigest.map(Self.validTitleDigest) != false, !window.role.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty, window.subrole.map({ !$0.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty }) != false, window.normalizedFloatingFrame.map(Self.validNormalizedFrame) != false, window.isFloating || window.normalizedFloatingFrame == nil else { throw WorkspaceMemoryError.invalidWindow(window.token) } if !window.isFloating { tiled.insert(window.token) } } guard Set(workspace.tree?.windows ?? []) == tiled else { throw WorkspaceMemoryError.invalidWorkspace(key) } } } /// Refreshes observed workspaces; absent records survive only within the age and count limits. public static func capture( _ state: State, preserving existing: WorkspaceMemory = WorkspaceMemory(), now: TimeInterval = 0, titleSalt: Data? = nil, pinned: [WindowID: WindowID] = [:], candidates: Set? = nil, preservingMissing: Set = [], maximumCount: Int = 128 ) throws -> WorkspaceMemory { try existing.validate() guard now.isFinite, now >= 0 else { throw WorkspaceMemoryError.invalidTimestamp } let salt = titleSalt ?? existing.titleSalt guard existing.records.allSatisfy({ $0.windows.isEmpty }) || salt == existing.titleSalt else { throw WorkspaceMemoryError.invalidTitleSalt } let digester = WorkspaceMemory(titleSalt: salt) try digester.validate() var records = Dictionary(uniqueKeysWithValues: existing.records.map { ($0.workspace.key, $0) }) let previousMapping = existing.windowMapping(in: state, pinned: pinned, candidates: candidates) var previousTokens: [WindowID: WindowID] = [:] for (token, id) in previousMapping { guard previousTokens.updateValue(token, forKey: id) == nil else { throw WorkspaceMemoryError.invalidWindow(id) } } var used = Set(existing.records.flatMap { $0.windows.map(\.token) }) var nextToken: UInt32 = 1 var capturedLive: Set = [] for key in state.workspaces.keys.sorted() where state.displays[key.display] != nil { guard let workspace = state.workspaces[key], let screen = state.displays[key.display]?.frame else { continue } if !state.isActive(key), workspace.order.isEmpty, records[key] != nil { continue } guard workspace.key == key else { throw WorkspaceMemoryError.invalidWorkspace(key) } var mapping: [WindowID: WindowID] = [:] var liveWindows: [SavedWindow] = [] var savedWindows: [SavedWindow] = [] for id in workspace.order { guard let window = state.windows[id], window.id == id, capturedLive.insert(id).inserted else { throw WorkspaceMemoryError.invalidWindow(id) } let token: WindowID if let previous = previousTokens[id] { token = previous } else { while used.contains(WindowID(rawValue: nextToken)) { guard nextToken < UInt32.max else { throw WorkspaceMemoryError.windowTokensExhausted } nextToken += 1 } token = WindowID(rawValue: nextToken) used.insert(token) } mapping[id] = token let frame = window.isFloating ? (state.frames[id] ?? state.observedFrames[id]) : nil if let frame, !frame.isValid { throw WorkspaceMemoryError.invalidWindow(id) } let digest = try digester.titleDigest(for: window.title) let liveWindow = SavedWindow( token: id, bundleID: window.app.bundleID, titleDigest: digest, role: window.role, subrole: window.subrole, display: key.display, isFloating: window.isFloating, normalizedFloatingFrame: frame.flatMap { Self.normalize($0, in: screen) }) liveWindows.append(liveWindow) savedWindows.append(liveWindow.retokened(token)) } _ = try WorkspaceMemory( records: [Record(workspace: workspace, windows: liveWindows, lastSeen: now)], titleSalt: salt) var record = Record( workspace: workspace.memoryRemapping(mapping), windows: savedWindows, lastSeen: now) if let previous = records[key] { record = try record.mergingMissingWindows(from: previous, tokens: preservingMissing) } records[key] = record } return try WorkspaceMemory(records: Array(records.values), titleSalt: salt) .pruned(asOf: now, maximumCount: maximumCount) } /// Tokens are not live IDs. Only active cross-display matching may span displays' distinct active Spaces. public func windowMapping( in state: State, pinned: [WindowID: WindowID] = [:], candidates: Set? = nil, acrossDisplays: Bool = false, activeOnly: Bool = false ) -> [WindowID: WindowID] { var savedGroups: [Identity: [SavedWindow]] = [:] var liveGroups: [Identity: [ManagedWindow]] = [:] var result: [WindowID: WindowID] = [:] var assigned: Set = [] var eligibleTokens: Set = [] let reserved = Set(pinned.values) for record in records { let key = record.workspace.key let eligible = state.displays[key.display] != nil && (!activeOnly || (state.isActive(key) && state.displays[key.display]?.hasUsableGeometry == true)) guard eligible || acrossDisplays else { continue } for window in record.windows { if eligible { eligibleTokens.insert(window.token) } let identity = Identity(window, key: key, acrossDisplays: acrossDisplays, activeOnly: activeOnly) if let id = pinned[window.token] { if eligible, let live = state.windows[id], let source = state.workspace(containing: id), (!activeOnly || (state.isActive(source) && state.displays[source.display]?.hasUsableGeometry == true)), Identity(live, key: source, acrossDisplays: acrossDisplays, activeOnly: activeOnly) == identity, assigned.insert(id).inserted { result[window.token] = id } continue } savedGroups[identity, default: []].append(window) } } for key in state.workspaces.keys.sorted() where state.displays[key.display] != nil { guard !activeOnly || (state.isActive(key) && state.displays[key.display]?.hasUsableGeometry == true) else { continue } for id in state.workspaces[key]?.order ?? [] where !reserved.contains(id) { guard let window = state.windows[id] else { continue } liveGroups[ Identity(window, key: key, acrossDisplays: acrossDisplays, activeOnly: activeOnly), default: [] ].append(window) } } for (identity, saved) in savedGroups { let live = liveGroups[identity] ?? [] let savedTitles = Dictionary(grouping: saved, by: \.titleDigest) let liveTitles = Dictionary(grouping: live, by: { Self.digest($0.title, salt: titleSalt) }) for (title, windows) in savedTitles where title != nil && windows.count == 1 { guard eligibleTokens.contains(windows[0].token), let matches = liveTitles[title], matches.count == 1, candidates?.contains(matches[0].id) != false else { continue } result[windows[0].token] = matches[0].id } // Candidate filtering must not make an ambiguous identity appear one-to-one. if saved.count == 1, live.count == 1, eligibleTokens.contains(saved[0].token), saved[0].titleDigest != nil, Self.digest(live[0].title, salt: titleSalt) != nil, candidates?.contains(live[0].id) != false { result[saved[0].token] = live[0].id } } return result } /// The caller owns restoration lifetime; pinned tokens cannot be reassigned as titles change. public func restoring( _ state: State, restoreWindows: Bool = true, pinned: [WindowID: WindowID] = [:], candidates: Set? = nil, mapping supplied: [WindowID: WindowID]? = nil, restoringTiling: Bool = false, activeOnly: Bool = false ) -> State { var result = state let mapping = restoreWindows ? (supplied ?? windowMapping(in: state, pinned: pinned, candidates: candidates, activeOnly: activeOnly)) : [:] if supplied != nil { var verified: Set = [] var knownTokens: Set = [] for record in records { let key = record.workspace.key for saved in record.windows { knownTokens.insert(saved.token) guard let id = mapping[saved.token] else { continue } let live = state.windows[id] let source = state.workspace(containing: id) let permittedSource = source.map { source in state.displays[source.display] != nil && (!activeOnly || (state.isActive(source) && state.isActive(key) && state.displays[source.display]?.hasUsableGeometry == true && state.displays[key.display]?.hasUsableGeometry == true)) && (source.space == key.space || (restoringTiling && activeOnly)) } == true precondition( verified.insert(id).inserted && state.displays[key.display] != nil && permittedSource && live?.app.bundleID == saved.bundleID && live?.role == saved.role && live?.subrole == saved.subrole && (restoringTiling || source == key), "Supplied memory matches require unique identities on recorded or active display Spaces") } } precondition( Set(mapping.keys).isSubset(of: knownTokens), "Supplied memory tokens must belong to the snapshot") } if restoringTiling { for record in records { let destination = record.workspace.key guard state.displays[destination.display] != nil, !activeOnly || state.isActive(destination) else { continue } for saved in record.windows { guard let id = mapping[saved.token], let live = state.windows[id], let source = state.workspace(containing: id), source.space == destination.space || (activeOnly && state.isActive(source) && state.isActive(destination)), live.app.bundleID == saved.bundleID, live.role == saved.role, live.subrole == saved.subrole else { continue } if source != destination { result.workspaces[source]?.remove(id) } result.windows[id]?.isFloating = saved.isFloating } } } for record in records where state.displays[record.workspace.key.display] != nil { let saved = record.workspace let key = saved.key guard let display = state.displays[key.display], !activeOnly || (state.isActive(key) && display.hasUsableGeometry) else { continue } let screen = display.frame let current = result.workspaces[key] ?? Workspace(key: key) var workspace = current.applyingMemorySettings(saved, display: display) guard restoreWindows else { if let focused = state.focusedWindow { workspace.select(focused) } result.workspaces[key] = workspace continue } for window in record.windows { guard let id = mapping[window.token], window.isFloating else { continue } result.windows[id]?.isFloating = true if let normalized = window.normalizedFloatingFrame { result.frames[id] = Self.clamped(Self.denormalize(normalized, in: screen), in: screen) } } let matched = saved.memoryRemapping(mapping) let matchedMembers = Set(matched.order) if !matchedMembers.isEmpty { let tiledMapping = mapping.filter { result.windows[$0.value]?.isFloating == false } workspace = saved.memoryRemapping(tiledMapping) workspace.order = matched.order workspace.openingOrder = matched.openingOrder workspace.focus = matched.focus ?? current.focus.flatMap { matchedMembers.contains($0) ? $0 : nil } workspace.adapt(to: screen, fullFrame: display.fullFrame) workspace.restoreAutomaticTiles() var insertionEffects: [Effect] = [] for id in current.order where !matchedMembers.contains(id) { guard let window = result.windows[id] else { continue } result.insertWindow( id, into: &workspace, floating: window.isFloating, frame: result.frames[id] ?? result.observedFrames[id] ?? screen, effects: &insertionEffects) } } if let focused = state.focusedWindow { workspace.select(focused) } result.workspaces[key] = workspace } return result } func identityCandidates(for saved: SavedWindow, workspace key: WorkspaceKey, in state: State) -> [WindowID] { let identity = Identity(saved, key: key, acrossDisplays: true, activeOnly: true) return state.workspaces.keys.sorted().filter { state.isActive($0) && state.displays[$0.display]?.hasUsableGeometry == true }.flatMap { source in (state.workspaces[source]?.order ?? []).filter { id in state.windows[id].map { Identity($0, key: source, acrossDisplays: true, activeOnly: true) == identity } == true } } } private struct Identity: Hashable { let bundleID: String let role: String let subrole: String? let display: DisplayID? let space: SpaceID? init(_ window: SavedWindow, key: WorkspaceKey, acrossDisplays: Bool = false, activeOnly: Bool = false) { bundleID = window.bundleID role = window.role subrole = window.subrole display = acrossDisplays ? nil : key.display space = acrossDisplays && activeOnly ? nil : key.space } init(_ window: ManagedWindow, key: WorkspaceKey, acrossDisplays: Bool = false, activeOnly: Bool = false) { bundleID = window.app.bundleID role = window.role subrole = window.subrole display = acrossDisplays ? nil : key.display space = acrossDisplays && activeOnly ? nil : key.space } } private static func digest(_ title: String, salt: Data) -> String? { let normalized = normalizedTitle(title) guard !normalized.isEmpty else { return nil } let digest = HMAC.authenticationCode( for: Data(normalized.utf8), using: SymmetricKey(data: salt)) return digest.map { String(format: "%02x", $0) }.joined() } private static func validTitleDigest(_ digest: String) -> Bool { digest.utf8.count == 64 && digest.utf8.allSatisfy { (48...57).contains($0) || (97...102).contains($0) } } private static func clamped(_ frame: Rect, in screen: Rect) -> Rect { let width = min(frame.size.width, screen.size.width) let height = min(frame.size.height, screen.size.height) return Rect( x: min(screen.maxX - width, max(screen.minX, frame.minX)), y: min(screen.maxY - height, max(screen.minY, frame.minY)), width: width, height: height) } private static func normalizedTitle(_ title: String) -> String { title.precomposedStringWithCanonicalMapping .folding(options: [.caseInsensitive], locale: Locale(identifier: "en_US_POSIX")) .split(whereSeparator: \.isWhitespace).joined(separator: " ") } private static func validLength(_ value: Double) -> Bool { value.isFinite && (0...1_000_000).contains(value) } private static func validSize(_ size: Size) -> Bool { validLength(size.width) && validLength(size.height) } private static func validInsets(_ insets: Insets) -> Bool { [insets.top, insets.left, insets.bottom, insets.right].allSatisfy(validLength) } private static func validNormalizedFrame(_ frame: Rect) -> Bool { frame.isValid && abs(frame.minX) <= 1_000_000 && abs(frame.minY) <= 1_000_000 && frame.size.width > 0 && frame.size.height > 0 && frame.size.width <= 1_000_000 && frame.size.height <= 1_000_000 } private static func validTree(_ tree: TileTree?, members: Set, cap: Int) -> Bool { guard let tree else { return true } return tree.isValid && tree.tileCount <= cap && Set(tree.windows).isSubset(of: members) } private static func normalize(_ frame: Rect, in screen: Rect) -> Rect? { guard screen.size.width > 0, screen.size.height > 0 else { return nil } return Rect( x: (frame.minX - screen.minX) / screen.size.width, y: (frame.minY - screen.minY) / screen.size.height, width: frame.size.width / screen.size.width, height: frame.size.height / screen.size.height) } private static func denormalize(_ frame: Rect, in screen: Rect) -> Rect { Rect( x: screen.minX + frame.minX * screen.size.width, y: screen.minY + frame.minY * screen.size.height, width: frame.size.width * screen.size.width, height: frame.size.height * screen.size.height) } } extension TileTree { func memoryRemapping(_ mapping: [WindowID: WindowID]) -> TileTree? { switch self { case .tile(let stack): return stack.memoryRemapping(mapping).map(TileTree.tile) case .split(let axis, let fraction, let first, let second): let left = first.memoryRemapping(mapping) let right = second.memoryRemapping(mapping) if let left, let right { return .split(axis: axis, fraction: fraction, first: left, second: right) } return left ?? right case .partition(let axis, let fraction, let first, let second): let left = first.memoryRemapping(mapping) let right = second.memoryRemapping(mapping) if let left, let right { return .partition(axis: axis, fraction: fraction, first: left, second: right) } return left ?? right } } } extension Workspace { func memoryRemapping(_ mapping: [WindowID: WindowID]) -> Workspace { var result = self result.order = order.compactMap { mapping[$0] } result.openingOrder = openingOrder.compactMap { mapping[$0] } result.focus = focus.flatMap { mapping[$0] } result.tree = tree?.memoryRemapping(mapping) result.alternateSideTree = alternateSideTree?.memoryRemapping(mapping) if let memory = adaptiveTileMemory, let original = memory.original.memoryRemapping(mapping), let projection = memory.projection.memoryRemapping(mapping) { result.adaptiveTileMemory = AdaptiveTileMemory(original: original, projection: projection) } else { result.adaptiveTileMemory = nil } if layout == .side, let primaryWindow, let primary = tree?.stack(containing: primaryWindow), primary.windows.allSatisfy({ mapping[$0] == nil }) { // A surviving sidebar is the new main area, not a full-display sidebar subtree. result.rebuild(stacks: result.tree?.stacks ?? []) } return result } fileprivate func applyingMemorySettings(_ saved: Workspace, display: Display) -> Workspace { var result = self if result.layout != saved.layout { result.changeLayout(saved.layout) } result.layoutDefaults = saved.layoutDefaults if result.ratio != saved.ratio { if result.layout == .side { result.changeRatio(saved.ratio) } else { result.ratio = saved.ratio } } result.configuredRatio = saved.configuredRatio result.gaps = saved.gaps result.reservedEdges = saved.reservedEdges result.whenFull = saved.whenFull result.pendingSplitAxis = saved.pendingSplitAxis result.setWindowCap(saved.windowCap) result.adapt(to: display.frame, fullFrame: display.fullFrame) return result } }