Something went wrong. Try again.
An auto tiler for macOS
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532import CryptoKitpublic import Foundationpublic import ParcelCoreimport 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<WorkspaceKey> = [] 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<WorkspaceKey> { var activated: Set<WorkspaceKey> = [] 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<WorkspaceKey>) { 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<WorkspaceKey> { var keys: Set<WorkspaceKey> = [] 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 }}