import Foundation import ParcelCore @MainActor final class MinimumResetTransaction { let bundleID: String? var previous: MinimumResetTransaction? var confirmed: [String: LearnedMinimumSize] = [:] var cleared = false init(bundleID: String?, previous: MinimumResetTransaction?) { self.bundleID = bundleID self.previous = previous } func includes(_ bundleID: String) -> Bool { self.bundleID == nil || self.bundleID == bundleID } } enum MinimumPersistenceError: LocalizedError { case save(any Error) case reset(any Error) var errorDescription: String? { switch self { case .save(let error): String( localized: "Could not save learned minimum sizes: \(error.localizedDescription)", table: "Minimums", bundle: .module) case .reset(let error): String( localized: "Could not reset learned minimum sizes: \(error.localizedDescription)", table: "Minimums", bundle: .module) } } } extension ParcelEngine { func inheritedMinimum(_ minimum: LearnedMinimumSize?, for window: WindowID) -> LearnedMinimumSize? { guard let minimum, let accepted = acceptedReadbacks[window]?.last?.accepted, accepted.isValid, accepted.size.width > 0, accepted.size.height > 0 else { return minimum } // A sibling's constraint cannot override a size this window has already accepted. let size = Size( width: minimum.size.width <= accepted.size.width ? minimum.size.width : 0, height: minimum.size.height <= accepted.size.height ? minimum.size.height : 0) guard size.width > 0 || size.height > 0 else { return nil } return LearnedMinimumSize(size: size, schemaVersion: minimum.schemaVersion) } func persistConfirmedMinimum(_ minimum: LearnedMinimumSize, for window: WindowID) { guard let bundleID = snapshot.state.windows[window]?.app.bundleID, !bundleID.isEmpty, !bundleID.contains(where: \.isWhitespace) else { return } var transaction = minimumResetInFlight var resets: [MinimumResetTransaction] = [] while let pending = transaction { if pending.includes(bundleID) { resets.append(pending) } transaction = pending.previous } guard minimumLearning.learned[bundleID] != minimum || !resets.isEmpty else { return } do { try minimumLearning.recordConfirmed(minimum, for: bundleID) for pending in resets { pending.confirmed[bundleID] = minimum } _ = scheduleMinimumSave() } catch { reportMinimumFailure(.save(error), underlying: error) } } @discardableResult private func scheduleMinimumSave() -> Task, Never>? { guard let store = minimumSizeStore else { return nil } let previous = minimumPersistence let task = Task { @MainActor in _ = await previous?.value // Read after the predecessor commits, so a queued save cannot restore a reset entry. let value = self.minimumLearning do { try await Task.detached { try store.save(value) }.value return Result.success(()) } catch { self.reportMinimumFailure(.save(error), underlying: error) return Result.failure(error) } } minimumPersistence = task return task } /// Clears one app's learned and pending entries, or all apps', returning whether any were removed. @discardableResult public func resetLearnedMinimums(for bundleID: String? = nil) async throws -> Bool { let store = minimumSizeStore return try await resetLearnedMinimums(for: bundleID) { staged in guard let store else { return } try await Task.detached { if bundleID == nil, staged.learned.isEmpty { try store.reset() } else { try store.save(staged) } }.value } } func resetLearnedMinimums( for bundleID: String?, persist: @escaping @Sendable (MinimumSizeLearning) async throws -> Void ) async throws -> Bool { if let bundleID, bundleID.isEmpty || bundleID.contains(where: \.isWhitespace) { throw MinimumSizeLearningError.invalidBundleID(bundleID) } let transaction = MinimumResetTransaction(bundleID: bundleID, previous: minimumResetInFlight) minimumResetInFlight = transaction let previous = minimumPersistence let task = Task { @MainActor in _ = await previous?.value defer { self.finishMinimumReset(transaction) } do { let staged = try self.minimumsAfterReset(transaction) try await persist(staged) // Confirmations received while disk I/O was suspended belong to the next learning pair. let committed = try self.minimumsAfterReset(transaction) transaction.cleared = self.minimumLearning.learned.keys.contains { committed.learned[$0] == nil } || self.minimumLearning.pending.keys.contains { committed.pending[$0] == nil } self.minimumLearning = committed self.clearMinimumReadbacks(for: bundleID) return Result.success(()) } catch { self.reportMinimumFailure(.reset(error), underlying: error) return Result.failure(error) } } minimumPersistence = task try await task.value.get() return transaction.cleared } private func minimumsAfterReset(_ transaction: MinimumResetTransaction) throws -> MinimumSizeLearning { var value = minimumLearning if let bundleID = transaction.bundleID { value.reset(for: bundleID) } else { value.resetAll() } for (bundleID, minimum) in transaction.confirmed { try value.recordConfirmed(minimum, for: bundleID) } return value } private func finishMinimumReset(_ transaction: MinimumResetTransaction) { if minimumResetInFlight === transaction { minimumResetInFlight = transaction.previous return } var pending = minimumResetInFlight while let current = pending { if current.previous === transaction { current.previous = transaction.previous return } pending = current.previous } preconditionFailure("Minimum reset transaction left its persistence queue") } private func reportMinimumFailure(_ failure: MinimumPersistenceError, underlying error: any Error) { log.record(.internalFailure(error)) onFailure?(failure) } private func clearMinimumReadbacks(for bundleID: String?) { let windows = snapshot.state.windows.values.filter { bundleID == nil || $0.app.bundleID == bundleID } let ids = Set(windows.map(\.id)) queue.removeAll { pending in if case .minimumSizeChanged(let id, _) = pending.event { return ids.contains(id) } return false } var state = snapshot.state for window in windows { // Retire old read-backs before a new resize can start another confirmation pair. cancelMotion(window.id, remove: false) minimumCandidates[window.id] = nil deferredResizeMinimums[window.id] = nil frameAdjustments[window.id] = nil frameWriteDiagnostics[window.id] = nil acceptedReadbacks[window.id] = nil pendingSizeFitResets.insert(window.id) correctiveWrites[window.id] = nil blockedWindows.remove(window.id) let native = window.facts?.minimumSize ?? observations[window.id]?.window.minimumSize let minimum = minimumLearning.learned[window.app.bundleID] ?? native.map { LearnedMinimumSize(size: $0) } if isRunning { enqueue(.minimumSizeChanged(window.id, minimum: minimum)) } else { state.windows[window.id]?.minimum = minimum } } if !isRunning { snapshot = EngineSnapshot(revision: snapshot.revision, state: state) } } }