import CryptoKit public import Foundation public import ParcelCore import ParcelPlatform public enum WorkspaceMemoryOperationError: Error, LocalizedError, Equatable, Sendable { case unavailable case busy public var errorDescription: String? { switch self { case .unavailable: String(localized: "Layout memory is unavailable. Inspect or reset its store in Settings.", bundle: .module) case .busy: String(localized: "Layout memory is resetting. Try again in a moment.", bundle: .module) } } } struct DepartingWorkspaceIdentity { let workspace: Workspace let applications: [WindowID: AppID] var retainedTokens: [WindowID: WindowID] } extension ParcelEngine { static let workspaceRestorationDuration = 10.0 static let workspaceSaveDelay = 1.5 public var workspaceMemoryFileURL: URL? { workspaceStateStore?.fileURL } public var pendingWorkspaceRestorationCount: Int { pendingRestorationMemory.records.count } func beginWorkspaceMemory() { guard workspaceLoading == nil else { return } workspaceStorageFailed = true workspaceLoading = Task { @MainActor [weak self] in guard let self else { return } defer { self.workspaceLoading = nil } await self.loadWorkspaceMemory(restoringSettings: false) self.workspaceMemoryDirty = true self.rememberWorkspaceState() } } func loadWorkspaceMemory(restoringSettings: Bool = true) async { guard configuration.memory.enabled, let store = workspaceStateStore else { return } let generation = lifetime do { let loaded = try await Task.detached { try store.load() }.value guard lifetime == generation, configuration.memory.enabled else { return } let memory = try loaded.pruned(asOf: Date().timeIntervalSince1970) rememberedWorkspaces = memory workspaceStorageFailed = false workspaceMemoryDirty = memory != loaded || (memory.records.isEmpty && !snapshot.state.windows.isEmpty) workspaceRestorationMapping = [:] workspaceRestorationSeen = [] departingWorkspaceIdentities = [:] workspaceRestoreDeadlines = [:] if restoringSettings { pendingRestorationMemory = memory guard !isWaitingForTour else { return } _ = activateWorkspaceRestoration(in: snapshot.state) let candidates = Set(snapshot.state.windows.keys) workspaceRestorationMapping = memory.windowMapping(in: snapshot.state, candidates: candidates) workspaceRestorationSeen.formUnion(candidates) let restored = memory.restoring( snapshot.state, restoreWindows: configuration.memory.restoreWindows, pinned: workspaceRestorationMapping, candidates: []) snapshot = EngineSnapshot(revision: revision, state: restored) finishResolvedWorkspaceRestoration() } } catch { guard lifetime == generation else { return } failWorkspaceMemory(error) } } private func failWorkspaceMemory(_ error: any Error) { workspaceStorageFailed = true pendingWorkspaceSave = nil workspaceSaveWake?.cancel() workspaceSaveWake = nil workspaceRestoreWake?.cancel() workspaceRestoreWake = nil pendingRestorationMemory = WorkspaceMemory() departingWorkspaceIdentities = [:] workspaceRestoreDeadlines = [:] log.record(.workspaceStorage(error)) } private func captureWorkspaceMemory(_ state: State, preservingMissing: Bool = true) throws -> WorkspaceMemory { let unresolved = preservingMissing ? Set( pendingRestorationMemory.records.flatMap { record in record.windows.compactMap { window in workspaceRestorationMapping[window.token] == nil ? window.token : nil } }) : [] workspaceMemoryCaptureCount += 1 return try WorkspaceMemory.capture( state, preserving: rememberedWorkspaces, now: Date().timeIntervalSince1970, pinned: workspaceRestorationMapping, preservingMissing: unresolved) } func rememberDepartingWorkspaces(_ events: [Event], state: State) { guard !isWaitingForTour, configuration.memory.enabled, !workspaceStorageFailed, workspaceStateStore != nil else { return } var keys: Set = [] for event in events { switch event { case .displaySetChanged(let updated): let removed = Set(state.displays.keys).subtracting(updated.map(\.id)) keys.formUnion(state.workspaces.keys.filter { removed.contains($0.display) }) case .activeSpaceChanged(let display, let space): if let previous = state.activeSpaces[display], previous != space { keys.insert(WorkspaceKey(display: display, space: previous)) } default: break } } guard !keys.isEmpty else { return } do { let captured = try captureWorkspaceMemory(state) let departing = captured.records.filter { keys.contains($0.workspace.key) } for key in keys { if let workspace = state.workspaces[key], let record = departing.first(where: { $0.workspace.key == key }) { // Capture writes live windows in workspace order and appends any preserved missing windows. let tokens = Dictionary( uniqueKeysWithValues: zip(workspace.order, record.windows.lazy.map(\.token))) departingWorkspaceIdentities[key] = DepartingWorkspaceIdentity( workspace: workspace, applications: Dictionary( uniqueKeysWithValues: workspace.order.compactMap { id in state.windows[id].map { (id, $0.app) } }), retainedTokens: tokens) } } // Visibility changes remove tree members; retain their layout before reducing those events. rememberedWorkspaces = captured pendingRestorationMemory = try WorkspaceMemory( records: pendingRestorationMemory.records.filter { !keys.contains($0.workspace.key) } + departing, titleSalt: rememberedWorkspaces.titleSalt) for key in keys { workspaceRestoreDeadlines[key] = nil } let tokens = Set(departing.flatMap { $0.windows.map(\.token) }) let windows = Set(tokens.compactMap { workspaceRestorationMapping[$0] }) .union(keys.flatMap { state.workspaces[$0]?.order ?? [] }) workspaceRestorationMapping = workspaceRestorationMapping.filter { !tokens.contains($0.key) } workspaceRestorationSeen.subtract(windows) workspaceMemoryDirty = true scheduleWorkspaceRestorationExpiry() } catch { failWorkspaceMemory(error) } } private func activateWorkspaceRestoration(in state: State) -> Set { var activated: Set = [] for record in pendingRestorationMemory.records { let key = record.workspace.key guard state.displays[key.display] != nil, state.isActive(key), workspaceRestoreDeadlines[key] == nil else { continue } workspaceRestoreDeadlines[key] = clock.now + Self.workspaceRestorationDuration activated.insert(key) } scheduleWorkspaceRestorationExpiry() return activated } private func scheduleWorkspaceRestorationExpiry() { workspaceRestoreWake?.cancel() workspaceRestoreWake = nil guard let deadline = workspaceRestoreDeadlines.values.min() else { return } let generation = lifetime workspaceRestoreWake = scheduler.schedule(after: max(0, deadline - clock.now)) { [weak self] in guard let self, self.lifetime == generation, !self.isWaitingForTour else { return } self.workspaceRestoreWake = nil let expired = Set( self.workspaceRestoreDeadlines.keys.filter { (self.workspaceRestoreDeadlines[$0] ?? .infinity) <= self.clock.now }) self.stopRestoringWorkspaces(expired) self.workspaceMemoryDirty = true self.rememberWorkspaceState() } } private func finishResolvedWorkspaceRestoration() { let resolved = Set( pendingRestorationMemory.records.compactMap { record -> WorkspaceKey? in let key = record.workspace.key guard workspaceRestoreDeadlines[key] != nil else { return nil } return !configuration.memory.restoreWindows || record.windows.allSatisfy { workspaceRestorationMapping[$0.token] != nil } ? key : nil }) stopRestoringWorkspaces(resolved) } func restoreWorkspaceState( _ reduced: State, previous: State, events: [Event], effects: inout [[Effect]] ) -> State { guard !isWaitingForTour, configuration.memory.enabled, !workspaceStorageFailed else { return reduced } stopRestoringWorkspaces(workspaceEdits(events, previous: previous, next: reduced)) guard !pendingRestorationMemory.records.isEmpty else { return reduced } for event in events { let id: WindowID switch event { case .windowDisappeared(let window), .windowMinimized(let window): id = window case .windowAppeared(let window, let key, _): guard let prior = previous.workspace(containing: window.id), prior != key else { continue } id = window.id case .displaySetChanged(let displays): let connected = Set(displays.map(\.id)) for key in departingWorkspaceIdentities.keys where !connected.contains(key.display) { departingWorkspaceIdentities[key]?.retainedTokens.removeAll() } continue default: continue } if let prior = previous.workspace(containing: id) { departingWorkspaceIdentities[prior]?.retainedTokens[id] = nil } } let intact = Set( pendingRestorationMemory.records.compactMap { record -> WorkspaceKey? in let key = record.workspace.key guard let identity = departingWorkspaceIdentities[key], reduced.isActive(key), record.windows.count == identity.applications.count, reduced.workspaces[key] == identity.workspace, identity.applications.allSatisfy({ reduced.windows[$0.key]?.app == $0.value }) else { return nil } return key }) // A retained live tree already has stronger identities than durable title-based reconstruction. stopRestoringWorkspaces(intact) guard !pendingRestorationMemory.records.isEmpty else { return reduced } let arrivals = Set( events.compactMap { event -> WindowID? in guard case .windowAppeared(let window, _, _) = event, !workspaceRestorationSeen.contains(window.id), previous.windows[window.id] == nil || previous.workspace(containing: window.id) != reduced.workspace(containing: window.id) else { return nil } return window.id }) let topologyChanged = events.contains { event in switch event { case .displaySetChanged, .activeSpaceChanged: true default: false } } guard !arrivals.isEmpty || topologyChanged else { return reduced } let activated = activateWorkspaceRestoration(in: reduced) let activeRecords = pendingRestorationMemory.records.filter { workspaceRestoreDeadlines[$0.workspace.key].map { $0 > clock.now } == true } do { let activeMemory = try WorkspaceMemory( records: activeRecords, titleSalt: pendingRestorationMemory.titleSalt) var pinned = workspaceRestorationMapping for record in activeRecords { let key = record.workspace.key guard let identity = departingWorkspaceIdentities[key] else { continue } for (id, token) in identity.retainedTokens where reduced.windows[id]?.app == identity.applications[id] && reduced.workspace(containing: id) == key { pinned[token] = id } } let mapping = activeMemory.windowMapping(in: reduced, pinned: pinned, candidates: arrivals) let newTokens = Set(mapping.keys.filter { workspaceRestorationMapping[$0] == nil }) workspaceRestorationMapping.merge(mapping) { previous, _ in previous } workspaceRestorationSeen.formUnion(arrivals) let changedRecords = activeRecords.filter { record in activated.contains(record.workspace.key) || record.windows.contains { newTokens.contains($0.token) } } let changedMemory = try WorkspaceMemory(records: changedRecords, titleSalt: activeMemory.titleSalt) let restored = changedMemory.restoring( reduced, restoreWindows: configuration.memory.restoreWindows, pinned: workspaceRestorationMapping, candidates: []) finishResolvedWorkspaceRestoration() guard restored != reduced else { return reduced } workspaceMemoryDirty = true return applyWorkspaceRestoration( restored, reduced: reduced, previous: previous, events: events, effects: &effects) } catch { failWorkspaceMemory(error) return reduced } } private func applyWorkspaceRestoration( _ restored: State, reduced: State, previous: State, events: [Event], effects: inout [[Effect]] ) -> State { snapNextPass = true let (laidOut, restorationEffects) = reduce(restored, .relayout) var baseline = previous.frames for event in events { switch event { case .windowAppeared(let window, _, let frame): baseline[window.id] = frame case .windowMovedByUser(let window, let frame), .windowResizedByUser(let window, let frame), .windowFrameEdited(let window, let frame): baseline[window] = frame default: break } } let writes = laidOut.frames.keys.sorted().compactMap { window -> WindowFrame? in guard let key = laidOut.workspace(containing: window), laidOut.isActive(key), let frame = laidOut.frames[window], frame != baseline[window] else { return nil } return WindowFrame(window: window, frame: frame) } for index in effects.indices { effects[index].removeAll { if case .setFrames = $0 { true } else { false } } } if !effects.isEmpty { if !writes.isEmpty { effects[0].insert(.setFrames(writes), at: 0) } effects[effects.count - 1].append( contentsOf: restorationEffects.filter { if case .setFrames = $0 { false } else { true } }) } for (window, managed) in laidOut.windows where managed.isFloating != reduced.windows[window]?.isFloating { manualFloating[window] = managed.isFloating intrinsicFloating[window] = managed.isFloating if classifications[window] != nil { classifications[window]?.disposition = managed.isFloating ? .float : .tile classifications[window]?.reason = .manual } } return laidOut } func stopRestoringWorkspaces(_ keys: Set) { guard !keys.isEmpty else { return } do { pendingRestorationMemory = try WorkspaceMemory( records: pendingRestorationMemory.records.filter { !keys.contains($0.workspace.key) }, titleSalt: pendingRestorationMemory.titleSalt) for key in keys { workspaceRestoreDeadlines[key] = nil departingWorkspaceIdentities[key] = nil } scheduleWorkspaceRestorationExpiry() } catch { failWorkspaceMemory(error) } } private func workspaceEdits(_ events: [Event], previous: State, next: State) -> Set { var keys: Set = [] for event in events { let windows: [WindowID] switch event { case .workspaceCommandIssued(_, let key): keys.insert(key) windows = [] case .commandIssued(.tileWindow(let window)): windows = [window] case .commandIssued(let command): switch command { case .focus, .focusNextWindow, .focusPreviousWindow, .focusNextInStack, .focusPreviousInStack, .enterMode, .close, .toggleFullscreen: continue default: break } if let key = previous.activeWorkspace { keys.insert(key) } windows = [previous.focusedWindow, next.focusedWindow].compactMap { $0 } case .commandForWindow(let window, let command, _): guard command == .toggleFloat || command == .toggleFocus || command == .makePrimary else { continue } windows = [window] case .gestureCommitted(let gesture): switch gesture { case .swapTiles(let source, let target): windows = source.windows + target.windows case .fullHeight(let window), .resizeTile(let window, _), .moveToDisplay(let window, _), .floatingFrame(let window, _, _): windows = [window] case .drop(let source, _, let target, _): windows = [source] + (target.map { [$0] } ?? []) } case .windowDropped(let source, let target, _): windows = [source, target] case .tileEdgeResized(let edge, _), .tileEdgeReset(let edge): keys.insert(edge.workspace) windows = [] case .windowFrameEdited(let window, _): guard next.windows[window]?.isFloating == true else { continue } windows = [window] case .resolveRoom(let window, let key, _): keys.insert(key) windows = [window] default: continue } for window in windows { if let key = previous.workspace(containing: window) { keys.insert(key) } if let key = next.workspace(containing: window) { keys.insert(key) } } } return keys.filter { previous.workspaces[$0] != next.workspaces[$0] || previous.modes(for: $0).focusedWindow != next.modes(for: $0).focusedWindow || previous.workspaces[$0]?.order.contains(where: { previous.windows[$0]?.isFloating != next.windows[$0]?.isFloating || previous.frames[$0] != next.frames[$0] }) == true } } func markWorkspaceMemoryChanges(previous: State, next: State, events: [Event]) { guard configuration.memory.enabled, workspaceStateStore != nil, !workspaceStorageFailed else { return } let changed = previous.workspaces != next.workspaces || events.contains { event in switch event { case .windowAppeared(let window, _, _): return previous.windows[window.id] != next.windows[window.id] case .windowDisappeared(let window): return previous.windows[window] != next.windows[window] case .windowFrameEdited(let window, _), .windowMovedByUser(let window, _), .windowResizedByUser(let window, _): return next.windows[window]?.isFloating == true && previous.frames[window] != next.frames[window] case .displaySetChanged, .activeSpaceChanged: return previous.displays != next.displays || previous.activeSpaces != next.activeSpaces default: return false } } guard changed else { return } workspaceMemoryDirty = true workspaceSaveWake?.cancel() workspaceSaveWake = nil } private var workspaceMemoryIsEditing: Bool { pointerIsDown || !dragging.isEmpty || !dropping.isEmpty || !liveResizeWindows.isEmpty || !finalResizeWindows.isEmpty } func rememberWorkspaceState() { guard !isWaitingForTour, configuration.memory.enabled, !workspaceStorageFailed, !workspaceStorageIsResetting, workspaceStateStore != nil, workspaceMemoryDirty, !workspaceMemoryIsEditing, workspaceSaveWake == nil else { return } let generation = lifetime workspaceSaveWake = scheduler.schedule(after: Self.workspaceSaveDelay) { [weak self] in guard let self, self.lifetime == generation else { return } self.workspaceSaveWake = nil guard !self.workspaceMemoryIsEditing else { return } self.captureAndQueueWorkspaceMemory() } } private func captureAndQueueWorkspaceMemory(force: Bool = false) { guard !isWaitingForTour, configuration.memory.enabled, !workspaceStorageFailed, !workspaceStorageIsResetting, workspaceStateStore != nil, workspaceMemoryDirty || force else { return } do { let captured = try captureWorkspaceMemory(snapshot.state) workspaceMemoryDirty = false if captured != rememberedWorkspaces || force { rememberedWorkspaces = captured pendingWorkspaceSave = captured startWorkspaceSave() } } catch { failWorkspaceMemory(error) } } private func startWorkspaceSave() { guard workspacePersistence == nil, let store = workspaceStateStore else { return } workspacePersistence = Task { @MainActor [weak self] in guard let self else { return .success(()) } defer { self.workspacePersistence = nil } while let value = self.pendingWorkspaceSave { self.pendingWorkspaceSave = nil do { try await Task.detached { try store.save(value) }.value } catch { self.failWorkspaceMemory(error) return .failure(error) } } return .success(()) } } func flushWorkspaceMemoryOnStop() async { workspaceSaveWake?.cancel() workspaceSaveWake = nil workspaceRestoreWake?.cancel() workspaceRestoreWake = nil await workspaceLoading?.value captureAndQueueWorkspaceMemory() _ = await workspacePersistence?.value } public func saveWorkspaceMemory() async throws { guard !workspaceStorageIsResetting else { throw WorkspaceMemoryOperationError.busy } guard configuration.memory.enabled, workspaceStateStore != nil else { throw WorkspaceMemoryOperationError.unavailable } await workspaceLoading?.value if isRunning, !isFlushing, !queue.isEmpty { flush() } workspaceSaveWake?.cancel() workspaceSaveWake = nil captureAndQueueWorkspaceMemory(force: true) if let task = workspacePersistence { try await task.value.get() } if workspaceStorageFailed { throw WorkspaceMemoryOperationError.unavailable } } public func inspectWorkspaceMemory() async throws -> WorkspaceMemory { guard !workspaceStorageIsResetting else { throw WorkspaceMemoryOperationError.busy } guard let store = workspaceStateStore else { throw WorkspaceMemoryOperationError.unavailable } await workspaceLoading?.value if let task = workspacePersistence { try await task.value.get() } return try await Task.detached { try store.load() }.value } @discardableResult public func resetWorkspaceMemory() async throws -> URL? { guard !workspaceStorageIsResetting else { throw WorkspaceMemoryOperationError.busy } guard let store = workspaceStateStore else { throw WorkspaceMemoryOperationError.unavailable } workspaceStorageIsResetting = true defer { workspaceStorageIsResetting = false } workspaceSaveWake?.cancel() workspaceSaveWake = nil workspaceRestoreWake?.cancel() workspaceRestoreWake = nil pendingWorkspaceSave = nil await workspaceLoading?.value _ = await workspacePersistence?.value let preserved = try await Task.detached { try store.reset() }.value rememberedWorkspaces = WorkspaceMemory( titleSalt: SymmetricKey(size: .bits256).withUnsafeBytes { Data($0) }) pendingRestorationMemory = WorkspaceMemory() workspaceRestoreDeadlines = [:] workspaceRestorationMapping = [:] workspaceRestorationSeen = Set(snapshot.state.windows.keys) departingWorkspaceIdentities = [:] workspaceMemoryDirty = false workspaceStorageFailed = false return preserved } }